blob: a4bccacb2da99f56069fda2967e69c8c7a3c0327 [file] [log] [blame]
Steve Naroff0cca7492008-05-01 22:18:59 +00001//===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
Sebastian Redl5d3d41d2011-09-24 17:47:39 +000010// This file implements semantic analysis for initializers.
Chris Lattnerdd8e0062009-02-24 22:27:37 +000011//
Steve Naroff0cca7492008-05-01 22:18:59 +000012//===----------------------------------------------------------------------===//
13
Douglas Gregore737f502010-08-12 20:07:10 +000014#include "clang/Sema/Initialization.h"
Steve Naroff0cca7492008-05-01 22:18:59 +000015#include "clang/AST/ASTContext.h"
John McCall7cd088e2010-08-24 07:21:54 +000016#include "clang/AST/DeclObjC.h"
Anders Carlsson2078bb92009-05-27 16:10:08 +000017#include "clang/AST/ExprCXX.h"
Chris Lattner79e079d2009-02-24 23:10:27 +000018#include "clang/AST/ExprObjC.h"
Douglas Gregord6542d82009-12-22 15:35:07 +000019#include "clang/AST/TypeLoc.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000020#include "clang/Lex/Preprocessor.h"
21#include "clang/Sema/Designator.h"
22#include "clang/Sema/Lookup.h"
23#include "clang/Sema/SemaInternal.h"
Sebastian Redl2b916b82012-01-17 22:49:42 +000024#include "llvm/ADT/APInt.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000025#include "llvm/ADT/SmallString.h"
Douglas Gregor20093b42009-12-09 23:02:17 +000026#include "llvm/Support/ErrorHandling.h"
Jeffrey Yasskin19159132011-07-26 23:20:30 +000027#include "llvm/Support/raw_ostream.h"
Douglas Gregorc34ee5e2009-01-29 00:45:39 +000028#include <map>
Douglas Gregor05c13a32009-01-22 00:58:24 +000029using namespace clang;
Steve Naroff0cca7492008-05-01 22:18:59 +000030
Chris Lattnerdd8e0062009-02-24 22:27:37 +000031//===----------------------------------------------------------------------===//
32// Sema Initialization Checking
33//===----------------------------------------------------------------------===//
34
Hans Wennborg0ff50742013-05-15 11:03:04 +000035/// \brief Check whether T is compatible with a wide character type (wchar_t,
36/// char16_t or char32_t).
37static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38 if (Context.typesAreCompatible(Context.getWideCharType(), T))
39 return true;
40 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41 return Context.typesAreCompatible(Context.Char16Ty, T) ||
42 Context.typesAreCompatible(Context.Char32Ty, T);
43 }
44 return false;
45}
46
47enum StringInitFailureKind {
48 SIF_None,
49 SIF_NarrowStringIntoWideChar,
50 SIF_WideStringIntoChar,
51 SIF_IncompatWideStringIntoWideChar,
52 SIF_Other
53};
54
55/// \brief Check whether the array of type AT can be initialized by the Init
56/// expression by means of string initialization. Returns SIF_None if so,
57/// otherwise returns a StringInitFailureKind that describes why the
58/// initialization would not work.
59static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
60 ASTContext &Context) {
Eli Friedman8718a6a2009-05-29 18:22:49 +000061 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
Hans Wennborg0ff50742013-05-15 11:03:04 +000062 return SIF_Other;
Eli Friedman8718a6a2009-05-29 18:22:49 +000063
Chris Lattner8879e3b2009-02-26 23:26:43 +000064 // See if this is a string literal or @encode.
65 Init = Init->IgnoreParens();
Mike Stump1eb44332009-09-09 15:08:12 +000066
Chris Lattner8879e3b2009-02-26 23:26:43 +000067 // Handle @encode, which is a narrow string.
68 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
Hans Wennborg0ff50742013-05-15 11:03:04 +000069 return SIF_None;
Chris Lattner8879e3b2009-02-26 23:26:43 +000070
71 // Otherwise we can only handle string literals.
72 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
Hans Wennborg0ff50742013-05-15 11:03:04 +000073 if (SL == 0)
74 return SIF_Other;
Eli Friedmanbb6415c2009-05-31 10:54:53 +000075
Hans Wennborg0ff50742013-05-15 11:03:04 +000076 const QualType ElemTy =
77 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
Douglas Gregor5cee1192011-07-27 05:40:30 +000078
79 switch (SL->getKind()) {
80 case StringLiteral::Ascii:
81 case StringLiteral::UTF8:
82 // char array can be initialized with a narrow string.
83 // Only allow char x[] = "foo"; not char x[] = L"foo";
Hans Wennborg0ff50742013-05-15 11:03:04 +000084 if (ElemTy->isCharType())
85 return SIF_None;
86 if (IsWideCharCompatible(ElemTy, Context))
87 return SIF_NarrowStringIntoWideChar;
88 return SIF_Other;
89 // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
90 // "An array with element type compatible with a qualified or unqualified
91 // version of wchar_t, char16_t, or char32_t may be initialized by a wide
92 // string literal with the corresponding encoding prefix (L, u, or U,
93 // respectively), optionally enclosed in braces.
Douglas Gregor5cee1192011-07-27 05:40:30 +000094 case StringLiteral::UTF16:
Hans Wennborg0ff50742013-05-15 11:03:04 +000095 if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
96 return SIF_None;
97 if (ElemTy->isCharType())
98 return SIF_WideStringIntoChar;
99 if (IsWideCharCompatible(ElemTy, Context))
100 return SIF_IncompatWideStringIntoWideChar;
101 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000102 case StringLiteral::UTF32:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000103 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
104 return SIF_None;
105 if (ElemTy->isCharType())
106 return SIF_WideStringIntoChar;
107 if (IsWideCharCompatible(ElemTy, Context))
108 return SIF_IncompatWideStringIntoWideChar;
109 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000110 case StringLiteral::Wide:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000111 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
112 return SIF_None;
113 if (ElemTy->isCharType())
114 return SIF_WideStringIntoChar;
115 if (IsWideCharCompatible(ElemTy, Context))
116 return SIF_IncompatWideStringIntoWideChar;
117 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000118 }
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Douglas Gregor5cee1192011-07-27 05:40:30 +0000120 llvm_unreachable("missed a StringLiteral kind?");
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000121}
122
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000123static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
124 ASTContext &Context) {
John McCallce6c9b72011-02-21 07:22:22 +0000125 const ArrayType *arrayType = Context.getAsArrayType(declType);
Hans Wennborg0ff50742013-05-15 11:03:04 +0000126 if (!arrayType)
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000127 return SIF_Other;
128 return IsStringInit(init, arrayType, Context);
John McCallce6c9b72011-02-21 07:22:22 +0000129}
130
Richard Smith30ae1ed2013-05-05 16:40:13 +0000131/// Update the type of a string literal, including any surrounding parentheses,
132/// to match the type of the object which it is initializing.
133static void updateStringLiteralType(Expr *E, QualType Ty) {
Richard Smith27f9cf32013-05-06 00:35:47 +0000134 while (true) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000135 E->setType(Ty);
Richard Smith27f9cf32013-05-06 00:35:47 +0000136 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
137 break;
138 else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
139 E = PE->getSubExpr();
140 else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
141 E = UO->getSubExpr();
142 else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
143 E = GSE->getResultExpr();
144 else
145 llvm_unreachable("unexpected expr in string literal init");
Richard Smith30ae1ed2013-05-05 16:40:13 +0000146 }
Richard Smith30ae1ed2013-05-05 16:40:13 +0000147}
148
John McCallfef8b342011-02-21 07:57:55 +0000149static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
150 Sema &S) {
Chris Lattner79e079d2009-02-24 23:10:27 +0000151 // Get the length of the string as parsed.
152 uint64_t StrLength =
153 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
154
Mike Stump1eb44332009-09-09 15:08:12 +0000155
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000156 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000157 // C99 6.7.8p14. We have an array of character type with unknown size
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000158 // being initialized to a string literal.
Benjamin Kramer65263b42012-08-04 17:00:46 +0000159 llvm::APInt ConstVal(32, StrLength);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000160 // Return a new array type (C99 6.7.8p22).
John McCall46a617a2009-10-16 00:14:28 +0000161 DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
162 ConstVal,
163 ArrayType::Normal, 0);
Richard Smith30ae1ed2013-05-05 16:40:13 +0000164 updateStringLiteralType(Str, DeclT);
Chris Lattner19da8cd2009-02-24 23:01:39 +0000165 return;
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000166 }
Mike Stump1eb44332009-09-09 15:08:12 +0000167
Eli Friedman8718a6a2009-05-29 18:22:49 +0000168 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Mike Stump1eb44332009-09-09 15:08:12 +0000169
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000170 // We have an array of character type with known size. However,
Eli Friedman8718a6a2009-05-29 18:22:49 +0000171 // the size may be smaller or larger than the string we are initializing.
172 // FIXME: Avoid truncation for 64-bit length strings.
David Blaikie4e4d0842012-03-11 07:00:24 +0000173 if (S.getLangOpts().CPlusPlus) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000174 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
Anders Carlssonb8fc45f2011-04-14 00:41:11 +0000175 // For Pascal strings it's OK to strip off the terminating null character,
176 // so the example below is valid:
177 //
178 // unsigned char a[2] = "\pa";
179 if (SL->isPascal())
180 StrLength--;
181 }
182
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000183 // [dcl.init.string]p2
184 if (StrLength > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000185 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000186 diag::err_initializer_string_for_char_array_too_long)
187 << Str->getSourceRange();
188 } else {
189 // C99 6.7.8p14.
190 if (StrLength-1 > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000191 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000192 diag::warn_initializer_string_for_char_array_too_long)
193 << Str->getSourceRange();
194 }
Mike Stump1eb44332009-09-09 15:08:12 +0000195
Eli Friedman8718a6a2009-05-29 18:22:49 +0000196 // Set the type to the actual size that we are initializing. If we have
197 // something like:
198 // char x[1] = "foo";
199 // then this will set the string literal's type to char[1].
Richard Smith30ae1ed2013-05-05 16:40:13 +0000200 updateStringLiteralType(Str, DeclT);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000201}
202
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000203//===----------------------------------------------------------------------===//
204// Semantic checking for initializer lists.
205//===----------------------------------------------------------------------===//
206
Douglas Gregor9e80f722009-01-29 01:05:33 +0000207/// @brief Semantic checking for initializer lists.
208///
209/// The InitListChecker class contains a set of routines that each
210/// handle the initialization of a certain kind of entity, e.g.,
211/// arrays, vectors, struct/union types, scalars, etc. The
212/// InitListChecker itself performs a recursive walk of the subobject
213/// structure of the type to be initialized, while stepping through
214/// the initializer list one element at a time. The IList and Index
215/// parameters to each of the Check* routines contain the active
216/// (syntactic) initializer list and the index into that initializer
217/// list that represents the current initializer. Each routine is
218/// responsible for moving that Index forward as it consumes elements.
219///
220/// Each Check* routine also has a StructuredList/StructuredIndex
Abramo Bagnara63e7d252011-01-27 19:55:10 +0000221/// arguments, which contains the current "structured" (semantic)
Douglas Gregor9e80f722009-01-29 01:05:33 +0000222/// initializer list and the index into that initializer list where we
223/// are copying initializers as we map them over to the semantic
224/// list. Once we have completed our recursive walk of the subobject
225/// structure, we will have constructed a full semantic initializer
226/// list.
227///
228/// C99 designators cause changes in the initializer list traversal,
229/// because they make the initialization "jump" into a specific
230/// subobject and then continue the initialization from that
231/// point. CheckDesignatedInitializer() recursively steps into the
232/// designated subobject and manages backing out the recursion to
233/// initialize the subobjects after the one designated.
Chris Lattner8b419b92009-02-24 22:48:58 +0000234namespace {
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000235class InitListChecker {
Chris Lattner08202542009-02-24 22:50:46 +0000236 Sema &SemaRef;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000237 bool hadError;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000238 bool VerifyOnly; // no diagnostics, no structure building
Benjamin Kramera7894162012-02-23 14:48:40 +0000239 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000240 InitListExpr *FullyStructuredList;
Mike Stump1eb44332009-09-09 15:08:12 +0000241
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000242 void CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000243 InitListExpr *ParentIList, QualType T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000244 unsigned &Index, InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000245 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000246 void CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000247 InitListExpr *IList, QualType &T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000248 unsigned &Index, InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000249 unsigned &StructuredIndex,
250 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000251 void CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000252 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000253 bool SubobjectIsDesignatorContext,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000254 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000255 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000256 unsigned &StructuredIndex,
257 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000258 void CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000259 InitListExpr *IList, QualType ElemType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000260 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000261 InitListExpr *StructuredList,
262 unsigned &StructuredIndex);
Eli Friedman0c706c22011-09-19 23:17:44 +0000263 void CheckComplexType(const InitializedEntity &Entity,
264 InitListExpr *IList, QualType DeclType,
265 unsigned &Index,
266 InitListExpr *StructuredList,
267 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000268 void CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000269 InitListExpr *IList, QualType DeclType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000270 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000271 InitListExpr *StructuredList,
272 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000273 void CheckReferenceType(const InitializedEntity &Entity,
274 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +0000275 unsigned &Index,
276 InitListExpr *StructuredList,
277 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000278 void CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000279 InitListExpr *IList, QualType DeclType, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000280 InitListExpr *StructuredList,
281 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000282 void CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +0000283 InitListExpr *IList, QualType DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000284 RecordDecl::field_iterator Field,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000285 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000286 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000287 unsigned &StructuredIndex,
288 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000289 void CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +0000290 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000291 llvm::APSInt elementIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000292 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000293 InitListExpr *StructuredList,
294 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000295 bool CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +0000296 InitListExpr *IList, DesignatedInitExpr *DIE,
Douglas Gregor71199712009-04-15 04:56:10 +0000297 unsigned DesigIdx,
Mike Stump1eb44332009-09-09 15:08:12 +0000298 QualType &CurrentObjectType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000299 RecordDecl::field_iterator *NextField,
300 llvm::APSInt *NextElementIndex,
301 unsigned &Index,
302 InitListExpr *StructuredList,
303 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000304 bool FinishSubobjectInit,
305 bool TopLevelObject);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000306 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
307 QualType CurrentObjectType,
308 InitListExpr *StructuredList,
309 unsigned StructuredIndex,
310 SourceRange InitRange);
Douglas Gregor9e80f722009-01-29 01:05:33 +0000311 void UpdateStructuredListElement(InitListExpr *StructuredList,
312 unsigned &StructuredIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000313 Expr *expr);
314 int numArrayElements(QualType DeclType);
315 int numStructUnionElements(QualType DeclType);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000316
Douglas Gregord6d37de2009-12-22 00:05:34 +0000317 void FillInValueInitForField(unsigned Init, FieldDecl *Field,
318 const InitializedEntity &ParentEntity,
319 InitListExpr *ILE, bool &RequiresSecondPass);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000320 void FillInValueInitializations(const InitializedEntity &Entity,
321 InitListExpr *ILE, bool &RequiresSecondPass);
Eli Friedmanf40fd6b2011-08-23 22:24:57 +0000322 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
323 Expr *InitExpr, FieldDecl *Field,
324 bool TopLevelObject);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000325 void CheckValueInitializable(const InitializedEntity &Entity);
326
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000327public:
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000328 InitListChecker(Sema &S, const InitializedEntity &Entity,
Richard Smith40cba902013-06-06 11:41:05 +0000329 InitListExpr *IL, QualType &T, bool VerifyOnly);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000330 bool HadError() { return hadError; }
331
332 // @brief Retrieves the fully-structured initializer list used for
333 // semantic analysis and code generation.
334 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
335};
Chris Lattner8b419b92009-02-24 22:48:58 +0000336} // end anonymous namespace
Chris Lattner68355a52009-01-29 05:10:57 +0000337
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000338void InitListChecker::CheckValueInitializable(const InitializedEntity &Entity) {
339 assert(VerifyOnly &&
340 "CheckValueInitializable is only inteded for verification mode.");
341
342 SourceLocation Loc;
343 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
344 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000345 InitializationSequence InitSeq(SemaRef, Entity, Kind, None);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000346 if (InitSeq.Failed())
347 hadError = true;
348}
349
Douglas Gregord6d37de2009-12-22 00:05:34 +0000350void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
351 const InitializedEntity &ParentEntity,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000352 InitListExpr *ILE,
Douglas Gregord6d37de2009-12-22 00:05:34 +0000353 bool &RequiresSecondPass) {
Daniel Dunbar96a00142012-03-09 18:35:03 +0000354 SourceLocation Loc = ILE->getLocStart();
Douglas Gregord6d37de2009-12-22 00:05:34 +0000355 unsigned NumInits = ILE->getNumInits();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000356 InitializedEntity MemberEntity
Douglas Gregord6d37de2009-12-22 00:05:34 +0000357 = InitializedEntity::InitializeMember(Field, &ParentEntity);
358 if (Init >= NumInits || !ILE->getInit(Init)) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000359 // If there's no explicit initializer but we have a default initializer, use
360 // that. This only happens in C++1y, since classes with default
361 // initializers are not aggregates in C++11.
362 if (Field->hasInClassInitializer()) {
363 Expr *DIE = CXXDefaultInitExpr::Create(SemaRef.Context,
364 ILE->getRBraceLoc(), Field);
365 if (Init < NumInits)
366 ILE->setInit(Init, DIE);
367 else {
368 ILE->updateInit(SemaRef.Context, Init, DIE);
369 RequiresSecondPass = true;
370 }
371 return;
372 }
373
Douglas Gregord6d37de2009-12-22 00:05:34 +0000374 // FIXME: We probably don't need to handle references
375 // specially here, since value-initialization of references is
376 // handled in InitializationSequence.
377 if (Field->getType()->isReferenceType()) {
378 // C++ [dcl.init.aggr]p9:
379 // If an incomplete or empty initializer-list leaves a
380 // member of reference type uninitialized, the program is
381 // ill-formed.
382 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
383 << Field->getType()
384 << ILE->getSyntacticForm()->getSourceRange();
385 SemaRef.Diag(Field->getLocation(),
386 diag::note_uninit_reference_member);
387 hadError = true;
388 return;
389 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000390
Douglas Gregord6d37de2009-12-22 00:05:34 +0000391 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
392 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000393 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000394 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000395 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000396 hadError = true;
397 return;
398 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000399
John McCall60d7b3a2010-08-24 06:29:42 +0000400 ExprResult MemberInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000401 = InitSeq.Perform(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000402 if (MemberInit.isInvalid()) {
403 hadError = true;
404 return;
405 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000406
Douglas Gregord6d37de2009-12-22 00:05:34 +0000407 if (hadError) {
408 // Do nothing
409 } else if (Init < NumInits) {
410 ILE->setInit(Init, MemberInit.takeAs<Expr>());
Sebastian Redl7491c492011-06-05 13:59:11 +0000411 } else if (InitSeq.isConstructorInitialization()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000412 // Value-initialization requires a constructor call, so
413 // extend the initializer list to include the constructor
414 // call and make a note that we'll need to take another pass
415 // through the initializer list.
Ted Kremenek709210f2010-04-13 23:39:13 +0000416 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
Douglas Gregord6d37de2009-12-22 00:05:34 +0000417 RequiresSecondPass = true;
418 }
419 } else if (InitListExpr *InnerILE
420 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000421 FillInValueInitializations(MemberEntity, InnerILE,
422 RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000423}
424
Douglas Gregor4c678342009-01-28 21:54:33 +0000425/// Recursively replaces NULL values within the given initializer list
426/// with expressions that perform value-initialization of the
427/// appropriate type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000428void
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000429InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
430 InitListExpr *ILE,
431 bool &RequiresSecondPass) {
Mike Stump1eb44332009-09-09 15:08:12 +0000432 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
Douglas Gregor930d8b52009-01-30 22:09:00 +0000433 "Should not have void type");
Daniel Dunbar96a00142012-03-09 18:35:03 +0000434 SourceLocation Loc = ILE->getLocStart();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000435 if (ILE->getSyntacticForm())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000436 Loc = ILE->getSyntacticForm()->getLocStart();
Mike Stump1eb44332009-09-09 15:08:12 +0000437
Ted Kremenek6217b802009-07-29 21:53:49 +0000438 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000439 const RecordDecl *RDecl = RType->getDecl();
440 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000441 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
442 Entity, ILE, RequiresSecondPass);
Richard Smithc3bf52c2013-04-20 22:23:05 +0000443 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
444 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
445 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
446 FieldEnd = RDecl->field_end();
447 Field != FieldEnd; ++Field) {
448 if (Field->hasInClassInitializer()) {
449 FillInValueInitForField(0, *Field, Entity, ILE, RequiresSecondPass);
450 break;
451 }
452 }
453 } else {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000454 unsigned Init = 0;
Richard Smithc3bf52c2013-04-20 22:23:05 +0000455 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
456 FieldEnd = RDecl->field_end();
Douglas Gregord6d37de2009-12-22 00:05:34 +0000457 Field != FieldEnd; ++Field) {
458 if (Field->isUnnamedBitfield())
459 continue;
Douglas Gregor4c678342009-01-28 21:54:33 +0000460
Douglas Gregord6d37de2009-12-22 00:05:34 +0000461 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000462 return;
Douglas Gregord6d37de2009-12-22 00:05:34 +0000463
David Blaikie581deb32012-06-06 20:45:41 +0000464 FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000465 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000466 return;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000467
Douglas Gregord6d37de2009-12-22 00:05:34 +0000468 ++Init;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000469
Douglas Gregord6d37de2009-12-22 00:05:34 +0000470 // Only look at the first initialization of a union.
Richard Smithc3bf52c2013-04-20 22:23:05 +0000471 if (RDecl->isUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000472 break;
473 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000474 }
475
476 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000477 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000478
479 QualType ElementType;
Mike Stump1eb44332009-09-09 15:08:12 +0000480
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000481 InitializedEntity ElementEntity = Entity;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000482 unsigned NumInits = ILE->getNumInits();
483 unsigned NumElements = NumInits;
Chris Lattner08202542009-02-24 22:50:46 +0000484 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000485 ElementType = AType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000486 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
487 NumElements = CAType->getSize().getZExtValue();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000488 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000489 0, Entity);
John McCall183700f2009-09-21 23:43:11 +0000490 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000491 ElementType = VType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000492 NumElements = VType->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000493 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000494 0, Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000495 } else
Douglas Gregor4c678342009-01-28 21:54:33 +0000496 ElementType = ILE->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000497
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000498
Douglas Gregor87fd7032009-02-02 17:43:21 +0000499 for (unsigned Init = 0; Init != NumElements; ++Init) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000500 if (hadError)
501 return;
502
Anders Carlssond3d824d2010-01-23 04:34:47 +0000503 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
504 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000505 ElementEntity.setElementIndex(Init);
506
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000507 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : 0);
508 if (!InitExpr && !ILE->hasArrayFiller()) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000509 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
510 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000511 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000512 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000513 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, None);
Douglas Gregor87fd7032009-02-02 17:43:21 +0000514 hadError = true;
515 return;
516 }
517
John McCall60d7b3a2010-08-24 06:29:42 +0000518 ExprResult ElementInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000519 = InitSeq.Perform(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000520 if (ElementInit.isInvalid()) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000521 hadError = true;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000522 return;
523 }
524
525 if (hadError) {
526 // Do nothing
527 } else if (Init < NumInits) {
Argyrios Kyrtzidis3e8dc2a2011-04-21 20:03:38 +0000528 // For arrays, just set the expression used for value-initialization
529 // of the "holes" in the array.
530 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
531 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
532 else
533 ILE->setInit(Init, ElementInit.takeAs<Expr>());
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000534 } else {
535 // For arrays, just set the expression used for value-initialization
536 // of the rest of elements and exit.
537 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
538 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
539 return;
540 }
541
Sebastian Redl7491c492011-06-05 13:59:11 +0000542 if (InitSeq.isConstructorInitialization()) {
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000543 // Value-initialization requires a constructor call, so
544 // extend the initializer list to include the constructor
545 // call and make a note that we'll need to take another pass
546 // through the initializer list.
547 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
548 RequiresSecondPass = true;
549 }
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000550 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000551 } else if (InitListExpr *InnerILE
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000552 = dyn_cast_or_null<InitListExpr>(InitExpr))
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000553 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
Douglas Gregor4c678342009-01-28 21:54:33 +0000554 }
555}
556
Chris Lattner68355a52009-01-29 05:10:57 +0000557
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000558InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
Sebastian Redl14b0c192011-09-24 17:48:00 +0000559 InitListExpr *IL, QualType &T,
Richard Smith40cba902013-06-06 11:41:05 +0000560 bool VerifyOnly)
561 : SemaRef(S), VerifyOnly(VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000562 hadError = false;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000563
Eli Friedmanb85f7072008-05-19 19:16:24 +0000564 unsigned newIndex = 0;
Douglas Gregor4c678342009-01-28 21:54:33 +0000565 unsigned newStructuredIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000566 FullyStructuredList
Douglas Gregored8a93d2009-03-01 17:12:46 +0000567 = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000568 CheckExplicitInitList(Entity, IL, T, newIndex,
Anders Carlsson46f46592010-01-23 19:55:29 +0000569 FullyStructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000570 /*TopLevelObject=*/true);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000571
Sebastian Redl14b0c192011-09-24 17:48:00 +0000572 if (!hadError && !VerifyOnly) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000573 bool RequiresSecondPass = false;
574 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
Douglas Gregor16006c92009-12-16 18:50:27 +0000575 if (RequiresSecondPass && !hadError)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000576 FillInValueInitializations(Entity, FullyStructuredList,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000577 RequiresSecondPass);
578 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000579}
580
581int InitListChecker::numArrayElements(QualType DeclType) {
Eli Friedman638e1442008-05-25 13:22:35 +0000582 // FIXME: use a proper constant
583 int maxElements = 0x7FFFFFFF;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000584 if (const ConstantArrayType *CAT =
Chris Lattner08202542009-02-24 22:50:46 +0000585 SemaRef.Context.getAsConstantArrayType(DeclType)) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000586 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
587 }
588 return maxElements;
589}
590
591int InitListChecker::numStructUnionElements(QualType DeclType) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000592 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
Douglas Gregor4c678342009-01-28 21:54:33 +0000593 int InitializableMembers = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000594 for (RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000595 Field = structDecl->field_begin(),
596 FieldEnd = structDecl->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +0000597 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +0000598 if (!Field->isUnnamedBitfield())
Douglas Gregor4c678342009-01-28 21:54:33 +0000599 ++InitializableMembers;
600 }
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000601 if (structDecl->isUnion())
Eli Friedmanf84eda32008-05-25 14:03:31 +0000602 return std::min(InitializableMembers, 1);
603 return InitializableMembers - structDecl->hasFlexibleArrayMember();
Steve Naroff0cca7492008-05-01 22:18:59 +0000604}
605
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000606void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000607 InitListExpr *ParentIList,
Douglas Gregor4c678342009-01-28 21:54:33 +0000608 QualType T, unsigned &Index,
609 InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000610 unsigned &StructuredIndex) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000611 int maxElements = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000612
Steve Naroff0cca7492008-05-01 22:18:59 +0000613 if (T->isArrayType())
614 maxElements = numArrayElements(T);
Douglas Gregorfb87b892010-04-26 21:31:17 +0000615 else if (T->isRecordType())
Steve Naroff0cca7492008-05-01 22:18:59 +0000616 maxElements = numStructUnionElements(T);
Eli Friedmanb85f7072008-05-19 19:16:24 +0000617 else if (T->isVectorType())
John McCall183700f2009-09-21 23:43:11 +0000618 maxElements = T->getAs<VectorType>()->getNumElements();
Steve Naroff0cca7492008-05-01 22:18:59 +0000619 else
David Blaikieb219cfc2011-09-23 05:06:16 +0000620 llvm_unreachable("CheckImplicitInitList(): Illegal type");
Eli Friedmanb85f7072008-05-19 19:16:24 +0000621
Eli Friedman402256f2008-05-25 13:49:22 +0000622 if (maxElements == 0) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000623 if (!VerifyOnly)
624 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
625 diag::err_implicit_empty_initializer);
Douglas Gregor4c678342009-01-28 21:54:33 +0000626 ++Index;
Eli Friedman402256f2008-05-25 13:49:22 +0000627 hadError = true;
628 return;
629 }
630
Douglas Gregor4c678342009-01-28 21:54:33 +0000631 // Build a structured initializer list corresponding to this subobject.
632 InitListExpr *StructuredSubobjectInitList
Mike Stump1eb44332009-09-09 15:08:12 +0000633 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
634 StructuredIndex,
Daniel Dunbar96a00142012-03-09 18:35:03 +0000635 SourceRange(ParentIList->getInit(Index)->getLocStart(),
Douglas Gregored8a93d2009-03-01 17:12:46 +0000636 ParentIList->getSourceRange().getEnd()));
Douglas Gregor4c678342009-01-28 21:54:33 +0000637 unsigned StructuredSubobjectInitIndex = 0;
Eli Friedmanb85f7072008-05-19 19:16:24 +0000638
Douglas Gregor4c678342009-01-28 21:54:33 +0000639 // Check the element types and build the structural subobject.
Douglas Gregor87fd7032009-02-02 17:43:21 +0000640 unsigned StartIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000641 CheckListElementTypes(Entity, ParentIList, T,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000642 /*SubobjectIsDesignatorContext=*/false, Index,
Mike Stump1eb44332009-09-09 15:08:12 +0000643 StructuredSubobjectInitList,
Eli Friedman629f1182011-08-23 20:17:13 +0000644 StructuredSubobjectInitIndex);
Sebastian Redlc2235182011-10-16 18:19:28 +0000645
Richard Smith40cba902013-06-06 11:41:05 +0000646 if (!VerifyOnly) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000647 StructuredSubobjectInitList->setType(T);
Douglas Gregora6457962009-03-20 00:32:56 +0000648
Sebastian Redlc2235182011-10-16 18:19:28 +0000649 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000650 // Update the structured sub-object initializer so that it's ending
651 // range corresponds with the end of the last initializer it used.
652 if (EndIndex < ParentIList->getNumInits()) {
653 SourceLocation EndLoc
654 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
655 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
656 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000657
Sebastian Redlc2235182011-10-16 18:19:28 +0000658 // Complain about missing braces.
Sebastian Redl14b0c192011-09-24 17:48:00 +0000659 if (T->isArrayType() || T->isRecordType()) {
660 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
Richard Smith40cba902013-06-06 11:41:05 +0000661 diag::warn_missing_braces)
Sebastian Redl14b0c192011-09-24 17:48:00 +0000662 << StructuredSubobjectInitList->getSourceRange()
663 << FixItHint::CreateInsertion(
664 StructuredSubobjectInitList->getLocStart(), "{")
665 << FixItHint::CreateInsertion(
666 SemaRef.PP.getLocForEndOfToken(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000667 StructuredSubobjectInitList->getLocEnd()),
Sebastian Redl14b0c192011-09-24 17:48:00 +0000668 "}");
669 }
Tanya Lattner1e1d3962010-03-07 04:17:15 +0000670 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000671}
672
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000673void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000674 InitListExpr *IList, QualType &T,
Douglas Gregor4c678342009-01-28 21:54:33 +0000675 unsigned &Index,
676 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000677 unsigned &StructuredIndex,
678 bool TopLevelObject) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000679 assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
Sebastian Redl14b0c192011-09-24 17:48:00 +0000680 if (!VerifyOnly) {
681 SyntacticToSemantic[IList] = StructuredList;
682 StructuredList->setSyntacticForm(IList);
683 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000684 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
Anders Carlsson46f46592010-01-23 19:55:29 +0000685 Index, StructuredList, StructuredIndex, TopLevelObject);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000686 if (!VerifyOnly) {
Eli Friedman5c89c392012-02-23 02:25:10 +0000687 QualType ExprTy = T;
688 if (!ExprTy->isArrayType())
689 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000690 IList->setType(ExprTy);
691 StructuredList->setType(ExprTy);
692 }
Eli Friedman638e1442008-05-25 13:22:35 +0000693 if (hadError)
694 return;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000695
Eli Friedman638e1442008-05-25 13:22:35 +0000696 if (Index < IList->getNumInits()) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000697 // We have leftover initializers
Sebastian Redl14b0c192011-09-24 17:48:00 +0000698 if (VerifyOnly) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000699 if (SemaRef.getLangOpts().CPlusPlus ||
700 (SemaRef.getLangOpts().OpenCL &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000701 IList->getType()->isVectorType())) {
702 hadError = true;
703 }
704 return;
705 }
706
Eli Friedmane5408582009-05-29 20:20:05 +0000707 if (StructuredIndex == 1 &&
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000708 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
709 SIF_None) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000710 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
David Blaikie4e4d0842012-03-11 07:00:24 +0000711 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000712 DK = diag::err_excess_initializers_in_char_array_initializer;
Eli Friedmane5408582009-05-29 20:20:05 +0000713 hadError = true;
714 }
Eli Friedmanbb504d32008-05-19 20:12:18 +0000715 // Special-case
Chris Lattner08202542009-02-24 22:50:46 +0000716 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000717 << IList->getInit(Index)->getSourceRange();
Eli Friedmand8dc2102008-05-20 05:25:56 +0000718 } else if (!T->isIncompleteType()) {
Douglas Gregorb574e562009-01-30 22:26:29 +0000719 // Don't complain for incomplete types, since we'll get an error
720 // elsewhere
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000721 QualType CurrentObjectType = StructuredList->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000722 int initKind =
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000723 CurrentObjectType->isArrayType()? 0 :
724 CurrentObjectType->isVectorType()? 1 :
725 CurrentObjectType->isScalarType()? 2 :
726 CurrentObjectType->isUnionType()? 3 :
727 4;
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000728
729 unsigned DK = diag::warn_excess_initializers;
David Blaikie4e4d0842012-03-11 07:00:24 +0000730 if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmane5408582009-05-29 20:20:05 +0000731 DK = diag::err_excess_initializers;
732 hadError = true;
733 }
David Blaikie4e4d0842012-03-11 07:00:24 +0000734 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
Nate Begeman08634522009-07-07 21:53:06 +0000735 DK = diag::err_excess_initializers;
736 hadError = true;
737 }
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000738
Chris Lattner08202542009-02-24 22:50:46 +0000739 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000740 << initKind << IList->getInit(Index)->getSourceRange();
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000741 }
742 }
Eli Friedmancda25a92008-05-19 20:20:43 +0000743
Sebastian Redl14b0c192011-09-24 17:48:00 +0000744 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
745 !TopLevelObject)
Chris Lattner08202542009-02-24 22:50:46 +0000746 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
Douglas Gregora3a83512009-04-01 23:51:29 +0000747 << IList->getSourceRange()
Douglas Gregor849b2432010-03-31 17:46:05 +0000748 << FixItHint::CreateRemoval(IList->getLocStart())
749 << FixItHint::CreateRemoval(IList->getLocEnd());
Steve Naroff0cca7492008-05-01 22:18:59 +0000750}
751
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000752void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000753 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000754 QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +0000755 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +0000756 unsigned &Index,
757 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000758 unsigned &StructuredIndex,
759 bool TopLevelObject) {
Eli Friedman0c706c22011-09-19 23:17:44 +0000760 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
761 // Explicitly braced initializer for complex type can be real+imaginary
762 // parts.
763 CheckComplexType(Entity, IList, DeclType, Index,
764 StructuredList, StructuredIndex);
765 } else if (DeclType->isScalarType()) {
Anders Carlsson46f46592010-01-23 19:55:29 +0000766 CheckScalarType(Entity, IList, DeclType, Index,
767 StructuredList, StructuredIndex);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000768 } else if (DeclType->isVectorType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000769 CheckVectorType(Entity, IList, DeclType, Index,
Anders Carlsson46f46592010-01-23 19:55:29 +0000770 StructuredList, StructuredIndex);
Richard Smith20599392012-07-07 08:35:56 +0000771 } else if (DeclType->isRecordType()) {
772 assert(DeclType->isAggregateType() &&
773 "non-aggregate records should be handed in CheckSubElementType");
774 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
775 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
776 SubobjectIsDesignatorContext, Index,
777 StructuredList, StructuredIndex,
778 TopLevelObject);
779 } else if (DeclType->isArrayType()) {
780 llvm::APSInt Zero(
781 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
782 false);
783 CheckArrayType(Entity, IList, DeclType, Zero,
784 SubobjectIsDesignatorContext, Index,
785 StructuredList, StructuredIndex);
Steve Naroff61353522008-08-10 16:05:48 +0000786 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
787 // This type is invalid, issue a diagnostic.
Douglas Gregor4c678342009-01-28 21:54:33 +0000788 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000789 if (!VerifyOnly)
790 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
791 << DeclType;
Eli Friedmand8dc2102008-05-20 05:25:56 +0000792 hadError = true;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000793 } else if (DeclType->isReferenceType()) {
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000794 CheckReferenceType(Entity, IList, DeclType, Index,
795 StructuredList, StructuredIndex);
John McCallc12c5bb2010-05-15 11:32:37 +0000796 } else if (DeclType->isObjCObjectType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000797 if (!VerifyOnly)
798 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
799 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000800 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000801 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000802 if (!VerifyOnly)
803 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
804 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000805 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000806 }
807}
808
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000809void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000810 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000811 QualType ElemType,
Douglas Gregor4c678342009-01-28 21:54:33 +0000812 unsigned &Index,
813 InitListExpr *StructuredList,
814 unsigned &StructuredIndex) {
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000815 Expr *expr = IList->getInit(Index);
Richard Smith6242a452013-05-31 02:56:17 +0000816
817 if (ElemType->isReferenceType())
818 return CheckReferenceType(Entity, IList, ElemType, Index,
819 StructuredList, StructuredIndex);
820
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000821 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
Richard Smith20599392012-07-07 08:35:56 +0000822 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
823 unsigned newIndex = 0;
824 unsigned newStructuredIndex = 0;
825 InitListExpr *newStructuredList
826 = getStructuredSubobjectInit(IList, Index, ElemType,
827 StructuredList, StructuredIndex,
828 SubInitList->getSourceRange());
829 CheckExplicitInitList(Entity, SubInitList, ElemType, newIndex,
830 newStructuredList, newStructuredIndex);
831 ++StructuredIndex;
832 ++Index;
833 return;
834 }
835 assert(SemaRef.getLangOpts().CPlusPlus &&
836 "non-aggregate records are only possible in C++");
837 // C++ initialization is handled later.
838 }
839
Richard Smith6242a452013-05-31 02:56:17 +0000840 if (ElemType->isScalarType())
John McCallfef8b342011-02-21 07:57:55 +0000841 return CheckScalarType(Entity, IList, ElemType, Index,
842 StructuredList, StructuredIndex);
Anders Carlssond28b4282009-08-27 17:18:13 +0000843
John McCallfef8b342011-02-21 07:57:55 +0000844 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
845 // arrayType can be incomplete if we're initializing a flexible
846 // array member. There's nothing we can do with the completed
847 // type here, though.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000848
Hans Wennborg0ff50742013-05-15 11:03:04 +0000849 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
Eli Friedman8a5d9292011-09-26 19:09:09 +0000850 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +0000851 CheckStringInit(expr, ElemType, arrayType, SemaRef);
852 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
Eli Friedman8a5d9292011-09-26 19:09:09 +0000853 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000854 ++Index;
John McCallfef8b342011-02-21 07:57:55 +0000855 return;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000856 }
John McCallfef8b342011-02-21 07:57:55 +0000857
858 // Fall through for subaggregate initialization.
859
David Blaikie4e4d0842012-03-11 07:00:24 +0000860 } else if (SemaRef.getLangOpts().CPlusPlus) {
John McCallfef8b342011-02-21 07:57:55 +0000861 // C++ [dcl.init.aggr]p12:
862 // All implicit type conversions (clause 4) are considered when
Sebastian Redl5d3d41d2011-09-24 17:47:39 +0000863 // initializing the aggregate member with an initializer from
John McCallfef8b342011-02-21 07:57:55 +0000864 // an initializer-list. If the initializer can initialize a
865 // member, the member is initialized. [...]
866
867 // FIXME: Better EqualLoc?
868 InitializationKind Kind =
869 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000870 InitializationSequence Seq(SemaRef, Entity, Kind, expr);
John McCallfef8b342011-02-21 07:57:55 +0000871
872 if (Seq) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000873 if (!VerifyOnly) {
Richard Smithb6f8d282011-12-20 04:00:21 +0000874 ExprResult Result =
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000875 Seq.Perform(SemaRef, Entity, Kind, expr);
Richard Smithb6f8d282011-12-20 04:00:21 +0000876 if (Result.isInvalid())
877 hadError = true;
John McCallfef8b342011-02-21 07:57:55 +0000878
Sebastian Redl14b0c192011-09-24 17:48:00 +0000879 UpdateStructuredListElement(StructuredList, StructuredIndex,
Richard Smithb6f8d282011-12-20 04:00:21 +0000880 Result.takeAs<Expr>());
Sebastian Redl14b0c192011-09-24 17:48:00 +0000881 }
John McCallfef8b342011-02-21 07:57:55 +0000882 ++Index;
883 return;
884 }
885
886 // Fall through for subaggregate initialization
887 } else {
888 // C99 6.7.8p13:
889 //
890 // The initializer for a structure or union object that has
891 // automatic storage duration shall be either an initializer
892 // list as described below, or a single expression that has
893 // compatible structure or union type. In the latter case, the
894 // initial value of the object, including unnamed members, is
895 // that of the expression.
John Wiegley429bb272011-04-08 18:41:53 +0000896 ExprResult ExprRes = SemaRef.Owned(expr);
John McCallfef8b342011-02-21 07:57:55 +0000897 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000898 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
899 !VerifyOnly)
John McCallfef8b342011-02-21 07:57:55 +0000900 == Sema::Compatible) {
John Wiegley429bb272011-04-08 18:41:53 +0000901 if (ExprRes.isInvalid())
902 hadError = true;
903 else {
904 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000905 if (ExprRes.isInvalid())
906 hadError = true;
John Wiegley429bb272011-04-08 18:41:53 +0000907 }
908 UpdateStructuredListElement(StructuredList, StructuredIndex,
909 ExprRes.takeAs<Expr>());
John McCallfef8b342011-02-21 07:57:55 +0000910 ++Index;
911 return;
912 }
John Wiegley429bb272011-04-08 18:41:53 +0000913 ExprRes.release();
John McCallfef8b342011-02-21 07:57:55 +0000914 // Fall through for subaggregate initialization
915 }
916
917 // C++ [dcl.init.aggr]p12:
918 //
919 // [...] Otherwise, if the member is itself a non-empty
920 // subaggregate, brace elision is assumed and the initializer is
921 // considered for the initialization of the first member of
922 // the subaggregate.
David Blaikie4e4d0842012-03-11 07:00:24 +0000923 if (!SemaRef.getLangOpts().OpenCL &&
Tanya Lattner61b4bc82011-07-15 23:07:01 +0000924 (ElemType->isAggregateType() || ElemType->isVectorType())) {
John McCallfef8b342011-02-21 07:57:55 +0000925 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
926 StructuredIndex);
927 ++StructuredIndex;
928 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000929 if (!VerifyOnly) {
930 // We cannot initialize this element, so let
931 // PerformCopyInitialization produce the appropriate diagnostic.
932 SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
933 SemaRef.Owned(expr),
934 /*TopLevelOfInitList=*/true);
935 }
John McCallfef8b342011-02-21 07:57:55 +0000936 hadError = true;
937 ++Index;
938 ++StructuredIndex;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000939 }
Eli Friedmanb85f7072008-05-19 19:16:24 +0000940}
941
Eli Friedman0c706c22011-09-19 23:17:44 +0000942void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
943 InitListExpr *IList, QualType DeclType,
944 unsigned &Index,
945 InitListExpr *StructuredList,
946 unsigned &StructuredIndex) {
947 assert(Index == 0 && "Index in explicit init list must be zero");
948
949 // As an extension, clang supports complex initializers, which initialize
950 // a complex number component-wise. When an explicit initializer list for
951 // a complex number contains two two initializers, this extension kicks in:
952 // it exepcts the initializer list to contain two elements convertible to
953 // the element type of the complex type. The first element initializes
954 // the real part, and the second element intitializes the imaginary part.
955
956 if (IList->getNumInits() != 2)
957 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
958 StructuredIndex);
959
960 // This is an extension in C. (The builtin _Complex type does not exist
961 // in the C++ standard.)
David Blaikie4e4d0842012-03-11 07:00:24 +0000962 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
Eli Friedman0c706c22011-09-19 23:17:44 +0000963 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
964 << IList->getSourceRange();
965
966 // Initialize the complex number.
967 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
968 InitializedEntity ElementEntity =
969 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
970
971 for (unsigned i = 0; i < 2; ++i) {
972 ElementEntity.setElementIndex(Index);
973 CheckSubElementType(ElementEntity, IList, elementType, Index,
974 StructuredList, StructuredIndex);
975 }
976}
977
978
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000979void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000980 InitListExpr *IList, QualType DeclType,
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000981 unsigned &Index,
Douglas Gregor4c678342009-01-28 21:54:33 +0000982 InitListExpr *StructuredList,
983 unsigned &StructuredIndex) {
John McCallb934c2d2010-11-11 00:46:36 +0000984 if (Index >= IList->getNumInits()) {
Richard Smith6b130222011-10-18 21:39:00 +0000985 if (!VerifyOnly)
986 SemaRef.Diag(IList->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +0000987 SemaRef.getLangOpts().CPlusPlus11 ?
Richard Smith6b130222011-10-18 21:39:00 +0000988 diag::warn_cxx98_compat_empty_scalar_initializer :
989 diag::err_empty_scalar_initializer)
990 << IList->getSourceRange();
Richard Smith80ad52f2013-01-02 11:42:31 +0000991 hadError = !SemaRef.getLangOpts().CPlusPlus11;
Douglas Gregor4c678342009-01-28 21:54:33 +0000992 ++Index;
993 ++StructuredIndex;
Eli Friedmanbb504d32008-05-19 20:12:18 +0000994 return;
Steve Naroff0cca7492008-05-01 22:18:59 +0000995 }
John McCallb934c2d2010-11-11 00:46:36 +0000996
997 Expr *expr = IList->getInit(Index);
998 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000999 if (!VerifyOnly)
1000 SemaRef.Diag(SubIList->getLocStart(),
1001 diag::warn_many_braces_around_scalar_init)
1002 << SubIList->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001003
1004 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1005 StructuredIndex);
1006 return;
1007 } else if (isa<DesignatedInitExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001008 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001009 SemaRef.Diag(expr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001010 diag::err_designator_for_scalar_init)
1011 << DeclType << expr->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001012 hadError = true;
1013 ++Index;
1014 ++StructuredIndex;
1015 return;
1016 }
1017
Sebastian Redl14b0c192011-09-24 17:48:00 +00001018 if (VerifyOnly) {
1019 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1020 hadError = true;
1021 ++Index;
1022 return;
1023 }
1024
John McCallb934c2d2010-11-11 00:46:36 +00001025 ExprResult Result =
1026 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001027 SemaRef.Owned(expr),
1028 /*TopLevelOfInitList=*/true);
John McCallb934c2d2010-11-11 00:46:36 +00001029
1030 Expr *ResultExpr = 0;
1031
1032 if (Result.isInvalid())
1033 hadError = true; // types weren't compatible.
1034 else {
1035 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001036
John McCallb934c2d2010-11-11 00:46:36 +00001037 if (ResultExpr != expr) {
1038 // The type was promoted, update initializer list.
1039 IList->setInit(Index, ResultExpr);
1040 }
1041 }
1042 if (hadError)
1043 ++StructuredIndex;
1044 else
1045 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1046 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001047}
1048
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001049void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1050 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +00001051 unsigned &Index,
1052 InitListExpr *StructuredList,
1053 unsigned &StructuredIndex) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001054 if (Index >= IList->getNumInits()) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001055 // FIXME: It would be wonderful if we could point at the actual member. In
1056 // general, it would be useful to pass location information down the stack,
1057 // so that we know the location (or decl) of the "current object" being
1058 // initialized.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001059 if (!VerifyOnly)
1060 SemaRef.Diag(IList->getLocStart(),
1061 diag::err_init_reference_member_uninitialized)
1062 << DeclType
1063 << IList->getSourceRange();
Douglas Gregor930d8b52009-01-30 22:09:00 +00001064 hadError = true;
1065 ++Index;
1066 ++StructuredIndex;
1067 return;
1068 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001069
1070 Expr *expr = IList->getInit(Index);
Richard Smith80ad52f2013-01-02 11:42:31 +00001071 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001072 if (!VerifyOnly)
1073 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1074 << DeclType << IList->getSourceRange();
1075 hadError = true;
1076 ++Index;
1077 ++StructuredIndex;
1078 return;
1079 }
1080
1081 if (VerifyOnly) {
1082 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1083 hadError = true;
1084 ++Index;
1085 return;
1086 }
1087
1088 ExprResult Result =
1089 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1090 SemaRef.Owned(expr),
1091 /*TopLevelOfInitList=*/true);
1092
1093 if (Result.isInvalid())
1094 hadError = true;
1095
1096 expr = Result.takeAs<Expr>();
1097 IList->setInit(Index, expr);
1098
1099 if (hadError)
1100 ++StructuredIndex;
1101 else
1102 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1103 ++Index;
Douglas Gregor930d8b52009-01-30 22:09:00 +00001104}
1105
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001106void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +00001107 InitListExpr *IList, QualType DeclType,
Douglas Gregor4c678342009-01-28 21:54:33 +00001108 unsigned &Index,
1109 InitListExpr *StructuredList,
1110 unsigned &StructuredIndex) {
John McCall20e047a2010-10-30 00:11:39 +00001111 const VectorType *VT = DeclType->getAs<VectorType>();
1112 unsigned maxElements = VT->getNumElements();
1113 unsigned numEltsInit = 0;
1114 QualType elementType = VT->getElementType();
Anders Carlsson46f46592010-01-23 19:55:29 +00001115
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001116 if (Index >= IList->getNumInits()) {
1117 // Make sure the element type can be value-initialized.
1118 if (VerifyOnly)
1119 CheckValueInitializable(
1120 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity));
1121 return;
1122 }
1123
David Blaikie4e4d0842012-03-11 07:00:24 +00001124 if (!SemaRef.getLangOpts().OpenCL) {
John McCall20e047a2010-10-30 00:11:39 +00001125 // If the initializing element is a vector, try to copy-initialize
1126 // instead of breaking it apart (which is doomed to failure anyway).
1127 Expr *Init = IList->getInit(Index);
1128 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001129 if (VerifyOnly) {
1130 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(Init)))
1131 hadError = true;
1132 ++Index;
1133 return;
1134 }
1135
John McCall20e047a2010-10-30 00:11:39 +00001136 ExprResult Result =
1137 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001138 SemaRef.Owned(Init),
1139 /*TopLevelOfInitList=*/true);
John McCall20e047a2010-10-30 00:11:39 +00001140
1141 Expr *ResultExpr = 0;
1142 if (Result.isInvalid())
1143 hadError = true; // types weren't compatible.
1144 else {
1145 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001146
John McCall20e047a2010-10-30 00:11:39 +00001147 if (ResultExpr != Init) {
1148 // The type was promoted, update initializer list.
1149 IList->setInit(Index, ResultExpr);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001150 }
1151 }
John McCall20e047a2010-10-30 00:11:39 +00001152 if (hadError)
1153 ++StructuredIndex;
1154 else
Sebastian Redl14b0c192011-09-24 17:48:00 +00001155 UpdateStructuredListElement(StructuredList, StructuredIndex,
1156 ResultExpr);
John McCall20e047a2010-10-30 00:11:39 +00001157 ++Index;
1158 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001159 }
Mike Stump1eb44332009-09-09 15:08:12 +00001160
John McCall20e047a2010-10-30 00:11:39 +00001161 InitializedEntity ElementEntity =
1162 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001163
John McCall20e047a2010-10-30 00:11:39 +00001164 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1165 // Don't attempt to go past the end of the init list
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001166 if (Index >= IList->getNumInits()) {
1167 if (VerifyOnly)
1168 CheckValueInitializable(ElementEntity);
John McCall20e047a2010-10-30 00:11:39 +00001169 break;
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001170 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001171
John McCall20e047a2010-10-30 00:11:39 +00001172 ElementEntity.setElementIndex(Index);
1173 CheckSubElementType(ElementEntity, IList, elementType, Index,
1174 StructuredList, StructuredIndex);
1175 }
1176 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001177 }
John McCall20e047a2010-10-30 00:11:39 +00001178
1179 InitializedEntity ElementEntity =
1180 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001181
John McCall20e047a2010-10-30 00:11:39 +00001182 // OpenCL initializers allows vectors to be constructed from vectors.
1183 for (unsigned i = 0; i < maxElements; ++i) {
1184 // Don't attempt to go past the end of the init list
1185 if (Index >= IList->getNumInits())
1186 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001187
John McCall20e047a2010-10-30 00:11:39 +00001188 ElementEntity.setElementIndex(Index);
1189
1190 QualType IType = IList->getInit(Index)->getType();
1191 if (!IType->isVectorType()) {
1192 CheckSubElementType(ElementEntity, IList, elementType, Index,
1193 StructuredList, StructuredIndex);
1194 ++numEltsInit;
1195 } else {
1196 QualType VecType;
1197 const VectorType *IVT = IType->getAs<VectorType>();
1198 unsigned numIElts = IVT->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001199
John McCall20e047a2010-10-30 00:11:39 +00001200 if (IType->isExtVectorType())
1201 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1202 else
1203 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
Bob Wilsone86d78c2010-11-10 21:56:12 +00001204 IVT->getVectorKind());
John McCall20e047a2010-10-30 00:11:39 +00001205 CheckSubElementType(ElementEntity, IList, VecType, Index,
1206 StructuredList, StructuredIndex);
1207 numEltsInit += numIElts;
1208 }
1209 }
1210
1211 // OpenCL requires all elements to be initialized.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001212 if (numEltsInit != maxElements) {
1213 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001214 SemaRef.Diag(IList->getLocStart(),
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001215 diag::err_vector_incorrect_num_initializers)
1216 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1217 hadError = true;
1218 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001219}
1220
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001221void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +00001222 InitListExpr *IList, QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001223 llvm::APSInt elementIndex,
Mike Stump1eb44332009-09-09 15:08:12 +00001224 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001225 unsigned &Index,
1226 InitListExpr *StructuredList,
1227 unsigned &StructuredIndex) {
John McCallce6c9b72011-02-21 07:22:22 +00001228 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1229
Steve Naroff0cca7492008-05-01 22:18:59 +00001230 // Check for the special-case of initializing an array with a string.
1231 if (Index < IList->getNumInits()) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001232 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1233 SIF_None) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001234 // We place the string literal directly into the resulting
1235 // initializer list. This is the only place where the structure
1236 // of the structured initializer list doesn't match exactly,
1237 // because doing so would involve allocating one character
1238 // constant for each string.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001239 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001240 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1241 UpdateStructuredListElement(StructuredList, StructuredIndex,
1242 IList->getInit(Index));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001243 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1244 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001245 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001246 return;
1247 }
1248 }
John McCallce6c9b72011-02-21 07:22:22 +00001249 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
Eli Friedman638e1442008-05-25 13:22:35 +00001250 // Check for VLAs; in standard C it would be possible to check this
1251 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1252 // them in all sorts of strange places).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001253 if (!VerifyOnly)
1254 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1255 diag::err_variable_object_no_init)
1256 << VAT->getSizeExpr()->getSourceRange();
Eli Friedman638e1442008-05-25 13:22:35 +00001257 hadError = true;
Douglas Gregor4c678342009-01-28 21:54:33 +00001258 ++Index;
1259 ++StructuredIndex;
Eli Friedman638e1442008-05-25 13:22:35 +00001260 return;
1261 }
1262
Douglas Gregor05c13a32009-01-22 00:58:24 +00001263 // We might know the maximum number of elements in advance.
Douglas Gregor4c678342009-01-28 21:54:33 +00001264 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1265 elementIndex.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001266 bool maxElementsKnown = false;
John McCallce6c9b72011-02-21 07:22:22 +00001267 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00001268 maxElements = CAT->getSize();
Jay Foad9f71a8f2010-12-07 08:25:34 +00001269 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001270 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001271 maxElementsKnown = true;
1272 }
1273
John McCallce6c9b72011-02-21 07:22:22 +00001274 QualType elementType = arrayType->getElementType();
Douglas Gregor05c13a32009-01-22 00:58:24 +00001275 while (Index < IList->getNumInits()) {
1276 Expr *Init = IList->getInit(Index);
1277 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001278 // If we're not the subobject that matches up with the '{' for
1279 // the designator, we shouldn't be handling the
1280 // designator. Return immediately.
1281 if (!SubobjectIsDesignatorContext)
1282 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001283
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001284 // Handle this designated initializer. elementIndex will be
1285 // updated to be the next array element we'll initialize.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001286 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001287 DeclType, 0, &elementIndex, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001288 StructuredList, StructuredIndex, true,
1289 false)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001290 hadError = true;
1291 continue;
1292 }
1293
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001294 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001295 maxElements = maxElements.extend(elementIndex.getBitWidth());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001296 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001297 elementIndex = elementIndex.extend(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001298 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001299
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001300 // If the array is of incomplete type, keep track of the number of
1301 // elements in the initializer.
1302 if (!maxElementsKnown && elementIndex > maxElements)
1303 maxElements = elementIndex;
1304
Douglas Gregor05c13a32009-01-22 00:58:24 +00001305 continue;
1306 }
1307
1308 // If we know the maximum number of elements, and we've already
1309 // hit it, stop consuming elements in the initializer list.
1310 if (maxElementsKnown && elementIndex == maxElements)
Steve Naroff0cca7492008-05-01 22:18:59 +00001311 break;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001312
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001313 InitializedEntity ElementEntity =
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001314 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001315 Entity);
1316 // Check this element.
1317 CheckSubElementType(ElementEntity, IList, elementType, Index,
1318 StructuredList, StructuredIndex);
Douglas Gregor05c13a32009-01-22 00:58:24 +00001319 ++elementIndex;
1320
1321 // If the array is of incomplete type, keep track of the number of
1322 // elements in the initializer.
1323 if (!maxElementsKnown && elementIndex > maxElements)
1324 maxElements = elementIndex;
Steve Naroff0cca7492008-05-01 22:18:59 +00001325 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001326 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +00001327 // If this is an incomplete array type, the actual type needs to
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001328 // be calculated here.
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001329 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001330 if (maxElements == Zero) {
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001331 // Sizing an array implicitly to zero is not allowed by ISO C,
1332 // but is supported by GNU.
Chris Lattner08202542009-02-24 22:50:46 +00001333 SemaRef.Diag(IList->getLocStart(),
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001334 diag::ext_typecheck_zero_array_size);
Steve Naroff0cca7492008-05-01 22:18:59 +00001335 }
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001336
Mike Stump1eb44332009-09-09 15:08:12 +00001337 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001338 ArrayType::Normal, 0);
Steve Naroff0cca7492008-05-01 22:18:59 +00001339 }
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001340 if (!hadError && VerifyOnly) {
1341 // Check if there are any members of the array that get value-initialized.
1342 // If so, check if doing that is possible.
1343 // FIXME: This needs to detect holes left by designated initializers too.
1344 if (maxElementsKnown && elementIndex < maxElements)
1345 CheckValueInitializable(InitializedEntity::InitializeElement(
1346 SemaRef.Context, 0, Entity));
1347 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001348}
1349
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001350bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1351 Expr *InitExpr,
1352 FieldDecl *Field,
1353 bool TopLevelObject) {
1354 // Handle GNU flexible array initializers.
1355 unsigned FlexArrayDiag;
1356 if (isa<InitListExpr>(InitExpr) &&
1357 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1358 // Empty flexible array init always allowed as an extension
1359 FlexArrayDiag = diag::ext_flexible_array_init;
David Blaikie4e4d0842012-03-11 07:00:24 +00001360 } else if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001361 // Disallow flexible array init in C++; it is not required for gcc
1362 // compatibility, and it needs work to IRGen correctly in general.
1363 FlexArrayDiag = diag::err_flexible_array_init;
1364 } else if (!TopLevelObject) {
1365 // Disallow flexible array init on non-top-level object
1366 FlexArrayDiag = diag::err_flexible_array_init;
1367 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1368 // Disallow flexible array init on anything which is not a variable.
1369 FlexArrayDiag = diag::err_flexible_array_init;
1370 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1371 // Disallow flexible array init on local variables.
1372 FlexArrayDiag = diag::err_flexible_array_init;
1373 } else {
1374 // Allow other cases.
1375 FlexArrayDiag = diag::ext_flexible_array_init;
1376 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001377
1378 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001379 SemaRef.Diag(InitExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001380 FlexArrayDiag)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001381 << InitExpr->getLocStart();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001382 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1383 << Field;
1384 }
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001385
1386 return FlexArrayDiag != diag::ext_flexible_array_init;
1387}
1388
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001389void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +00001390 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +00001391 QualType DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001392 RecordDecl::field_iterator Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001393 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001394 unsigned &Index,
1395 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001396 unsigned &StructuredIndex,
1397 bool TopLevelObject) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001398 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001399
Eli Friedmanb85f7072008-05-19 19:16:24 +00001400 // If the record is invalid, some of it's members are invalid. To avoid
1401 // confusion, we forgo checking the intializer for the entire record.
1402 if (structDecl->isInvalidDecl()) {
Richard Smith72ab2772012-09-28 21:23:50 +00001403 // Assume it was supposed to consume a single initializer.
1404 ++Index;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001405 hadError = true;
1406 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001407 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001408
1409 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001410 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Richard Smithc3bf52c2013-04-20 22:23:05 +00001411
1412 // If there's a default initializer, use it.
1413 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1414 if (VerifyOnly)
1415 return;
1416 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1417 Field != FieldEnd; ++Field) {
1418 if (Field->hasInClassInitializer()) {
1419 StructuredList->setInitializedFieldInUnion(*Field);
1420 // FIXME: Actually build a CXXDefaultInitExpr?
1421 return;
1422 }
1423 }
1424 }
1425
1426 // Value-initialize the first named member of the union.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001427 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1428 Field != FieldEnd; ++Field) {
1429 if (Field->getDeclName()) {
1430 if (VerifyOnly)
1431 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001432 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001433 else
David Blaikie581deb32012-06-06 20:45:41 +00001434 StructuredList->setInitializedFieldInUnion(*Field);
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001435 break;
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001436 }
1437 }
1438 return;
1439 }
1440
Douglas Gregor05c13a32009-01-22 00:58:24 +00001441 // If structDecl is a forward declaration, this loop won't do
1442 // anything except look at designated initializers; That's okay,
1443 // because an error should get printed out elsewhere. It might be
1444 // worthwhile to skip over the rest of the initializer, though.
Ted Kremenek6217b802009-07-29 21:53:49 +00001445 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001446 RecordDecl::field_iterator FieldEnd = RD->field_end();
Douglas Gregordfb5e592009-02-12 19:00:39 +00001447 bool InitializedSomething = false;
John McCall80639de2010-03-11 19:32:38 +00001448 bool CheckForMissingFields = true;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001449 while (Index < IList->getNumInits()) {
1450 Expr *Init = IList->getInit(Index);
1451
1452 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001453 // If we're not the subobject that matches up with the '{' for
1454 // the designator, we shouldn't be handling the
1455 // designator. Return immediately.
1456 if (!SubobjectIsDesignatorContext)
1457 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001458
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001459 // Handle this designated initializer. Field will be updated to
1460 // the next field that we'll be initializing.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001461 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001462 DeclType, &Field, 0, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001463 StructuredList, StructuredIndex,
1464 true, TopLevelObject))
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001465 hadError = true;
1466
Douglas Gregordfb5e592009-02-12 19:00:39 +00001467 InitializedSomething = true;
John McCall80639de2010-03-11 19:32:38 +00001468
1469 // Disable check for missing fields when designators are used.
1470 // This matches gcc behaviour.
1471 CheckForMissingFields = false;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001472 continue;
1473 }
1474
1475 if (Field == FieldEnd) {
1476 // We've run out of fields. We're done.
1477 break;
1478 }
1479
Douglas Gregordfb5e592009-02-12 19:00:39 +00001480 // We've already initialized a member of a union. We're done.
1481 if (InitializedSomething && DeclType->isUnionType())
1482 break;
1483
Douglas Gregor44b43212008-12-11 16:49:14 +00001484 // If we've hit the flexible array member at the end, we're done.
1485 if (Field->getType()->isIncompleteArrayType())
1486 break;
1487
Douglas Gregor0bb76892009-01-29 16:53:55 +00001488 if (Field->isUnnamedBitfield()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001489 // Don't initialize unnamed bitfields, e.g. "int : 20;"
Douglas Gregor05c13a32009-01-22 00:58:24 +00001490 ++Field;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001491 continue;
Steve Naroff0cca7492008-05-01 22:18:59 +00001492 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001493
Douglas Gregor54001c12011-06-29 21:51:31 +00001494 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001495 bool InvalidUse;
1496 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001497 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001498 else
David Blaikie581deb32012-06-06 20:45:41 +00001499 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001500 IList->getInit(Index)->getLocStart());
1501 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001502 ++Index;
1503 ++Field;
1504 hadError = true;
1505 continue;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001506 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001507
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001508 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001509 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001510 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1511 StructuredList, StructuredIndex);
Douglas Gregordfb5e592009-02-12 19:00:39 +00001512 InitializedSomething = true;
Douglas Gregor0bb76892009-01-29 16:53:55 +00001513
Sebastian Redl14b0c192011-09-24 17:48:00 +00001514 if (DeclType->isUnionType() && !VerifyOnly) {
Douglas Gregor0bb76892009-01-29 16:53:55 +00001515 // Initialize the first field within the union.
David Blaikie581deb32012-06-06 20:45:41 +00001516 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001517 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00001518
1519 ++Field;
Steve Naroff0cca7492008-05-01 22:18:59 +00001520 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001521
John McCall80639de2010-03-11 19:32:38 +00001522 // Emit warnings for missing struct field initializers.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001523 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1524 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1525 !DeclType->isUnionType()) {
John McCall80639de2010-03-11 19:32:38 +00001526 // It is possible we have one or more unnamed bitfields remaining.
1527 // Find first (if any) named field and emit warning.
1528 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1529 it != end; ++it) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001530 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
John McCall80639de2010-03-11 19:32:38 +00001531 SemaRef.Diag(IList->getSourceRange().getEnd(),
1532 diag::warn_missing_field_initializers) << it->getName();
1533 break;
1534 }
1535 }
1536 }
1537
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001538 // Check that any remaining fields can be value-initialized.
1539 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1540 !Field->getType()->isIncompleteArrayType()) {
1541 // FIXME: Should check for holes left by designated initializers too.
1542 for (; Field != FieldEnd && !hadError; ++Field) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001543 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001544 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001545 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001546 }
1547 }
1548
Mike Stump1eb44332009-09-09 15:08:12 +00001549 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
Douglas Gregora6457962009-03-20 00:32:56 +00001550 Index >= IList->getNumInits())
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001551 return;
1552
David Blaikie581deb32012-06-06 20:45:41 +00001553 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001554 TopLevelObject)) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001555 hadError = true;
Douglas Gregora6457962009-03-20 00:32:56 +00001556 ++Index;
1557 return;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001558 }
1559
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001560 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001561 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001562
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001563 if (isa<InitListExpr>(IList->getInit(Index)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001564 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001565 StructuredList, StructuredIndex);
1566 else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001567 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson987dc6a2010-01-23 20:47:59 +00001568 StructuredList, StructuredIndex);
Steve Naroff0cca7492008-05-01 22:18:59 +00001569}
Steve Naroff0cca7492008-05-01 22:18:59 +00001570
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001571/// \brief Expand a field designator that refers to a member of an
1572/// anonymous struct or union into a series of field designators that
1573/// refers to the field within the appropriate subobject.
1574///
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001575static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
Mike Stump1eb44332009-09-09 15:08:12 +00001576 DesignatedInitExpr *DIE,
1577 unsigned DesigIdx,
Francois Picheta0e27f02010-12-22 03:46:10 +00001578 IndirectFieldDecl *IndirectField) {
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001579 typedef DesignatedInitExpr::Designator Designator;
1580
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001581 // Build the replacement designators.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001582 SmallVector<Designator, 4> Replacements;
Francois Picheta0e27f02010-12-22 03:46:10 +00001583 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1584 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1585 if (PI + 1 == PE)
Mike Stump1eb44332009-09-09 15:08:12 +00001586 Replacements.push_back(Designator((IdentifierInfo *)0,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001587 DIE->getDesignator(DesigIdx)->getDotLoc(),
1588 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1589 else
1590 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1591 SourceLocation()));
Francois Picheta0e27f02010-12-22 03:46:10 +00001592 assert(isa<FieldDecl>(*PI));
1593 Replacements.back().setField(cast<FieldDecl>(*PI));
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001594 }
1595
1596 // Expand the current designator into the set of replacement
1597 // designators, so we have a full subobject path down to where the
1598 // member of the anonymous struct/union is actually stored.
Douglas Gregor319d57f2010-01-06 23:17:19 +00001599 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001600 &Replacements[0] + Replacements.size());
Francois Picheta0e27f02010-12-22 03:46:10 +00001601}
Mike Stump1eb44332009-09-09 15:08:12 +00001602
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001603/// \brief Given an implicit anonymous field, search the IndirectField that
Francois Picheta0e27f02010-12-22 03:46:10 +00001604/// corresponds to FieldName.
1605static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField,
1606 IdentifierInfo *FieldName) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001607 if (!FieldName)
1608 return 0;
1609
Francois Picheta0e27f02010-12-22 03:46:10 +00001610 assert(AnonField->isAnonymousStructOrUnion());
1611 Decl *NextDecl = AnonField->getNextDeclInContext();
Aaron Ballman3e78b192012-02-09 22:16:56 +00001612 while (IndirectFieldDecl *IF =
1613 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001614 if (FieldName == IF->getAnonField()->getIdentifier())
Francois Picheta0e27f02010-12-22 03:46:10 +00001615 return IF;
1616 NextDecl = NextDecl->getNextDeclInContext();
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001617 }
Francois Picheta0e27f02010-12-22 03:46:10 +00001618 return 0;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001619}
1620
Sebastian Redl14b0c192011-09-24 17:48:00 +00001621static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1622 DesignatedInitExpr *DIE) {
1623 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1624 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1625 for (unsigned I = 0; I < NumIndexExprs; ++I)
1626 IndexExprs[I] = DIE->getSubExpr(I + 1);
1627 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001628 DIE->size(), IndexExprs,
1629 DIE->getEqualOrColonLoc(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001630 DIE->usesGNUSyntax(), DIE->getInit());
1631}
1632
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001633namespace {
1634
1635// Callback to only accept typo corrections that are for field members of
1636// the given struct or union.
1637class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1638 public:
1639 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1640 : Record(RD) {}
1641
1642 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1643 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1644 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1645 }
1646
1647 private:
1648 RecordDecl *Record;
1649};
1650
1651}
1652
Douglas Gregor05c13a32009-01-22 00:58:24 +00001653/// @brief Check the well-formedness of a C99 designated initializer.
1654///
1655/// Determines whether the designated initializer @p DIE, which
1656/// resides at the given @p Index within the initializer list @p
1657/// IList, is well-formed for a current object of type @p DeclType
1658/// (C99 6.7.8). The actual subobject that this designator refers to
Mike Stump1eb44332009-09-09 15:08:12 +00001659/// within the current subobject is returned in either
Douglas Gregor4c678342009-01-28 21:54:33 +00001660/// @p NextField or @p NextElementIndex (whichever is appropriate).
Douglas Gregor05c13a32009-01-22 00:58:24 +00001661///
1662/// @param IList The initializer list in which this designated
1663/// initializer occurs.
1664///
Douglas Gregor71199712009-04-15 04:56:10 +00001665/// @param DIE The designated initializer expression.
1666///
1667/// @param DesigIdx The index of the current designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001668///
Dmitri Gribenko70517ca2012-08-23 17:58:28 +00001669/// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
Douglas Gregor05c13a32009-01-22 00:58:24 +00001670/// into which the designation in @p DIE should refer.
1671///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001672/// @param NextField If non-NULL and the first designator in @p DIE is
1673/// a field, this will be set to the field declaration corresponding
1674/// to the field named by the designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001675///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001676/// @param NextElementIndex If non-NULL and the first designator in @p
1677/// DIE is an array designator or GNU array-range designator, this
1678/// will be set to the last index initialized by this designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001679///
1680/// @param Index Index into @p IList where the designated initializer
1681/// @p DIE occurs.
1682///
Douglas Gregor4c678342009-01-28 21:54:33 +00001683/// @param StructuredList The initializer list expression that
1684/// describes all of the subobject initializers in the order they'll
1685/// actually be initialized.
1686///
Douglas Gregor05c13a32009-01-22 00:58:24 +00001687/// @returns true if there was an error, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00001688bool
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001689InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001690 InitListExpr *IList,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001691 DesignatedInitExpr *DIE,
1692 unsigned DesigIdx,
1693 QualType &CurrentObjectType,
1694 RecordDecl::field_iterator *NextField,
1695 llvm::APSInt *NextElementIndex,
1696 unsigned &Index,
1697 InitListExpr *StructuredList,
1698 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001699 bool FinishSubobjectInit,
1700 bool TopLevelObject) {
Douglas Gregor71199712009-04-15 04:56:10 +00001701 if (DesigIdx == DIE->size()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001702 // Check the actual initialization for the designated object type.
1703 bool prevHadError = hadError;
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001704
1705 // Temporarily remove the designator expression from the
1706 // initializer list that the child calls see, so that we don't try
1707 // to re-process the designator.
1708 unsigned OldIndex = Index;
1709 IList->setInit(OldIndex, DIE->getInit());
1710
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001711 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001712 StructuredList, StructuredIndex);
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001713
1714 // Restore the designated initializer expression in the syntactic
1715 // form of the initializer list.
1716 if (IList->getInit(OldIndex) != DIE->getInit())
1717 DIE->setInit(IList->getInit(OldIndex));
1718 IList->setInit(OldIndex, DIE);
1719
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001720 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001721 }
1722
Douglas Gregor71199712009-04-15 04:56:10 +00001723 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001724 bool IsFirstDesignator = (DesigIdx == 0);
1725 if (!VerifyOnly) {
1726 assert((IsFirstDesignator || StructuredList) &&
1727 "Need a non-designated initializer list to start from");
1728
1729 // Determine the structural initializer list that corresponds to the
1730 // current subobject.
Benjamin Kramera7894162012-02-23 14:48:40 +00001731 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001732 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1733 StructuredList, StructuredIndex,
Erik Verbruggen65d78312012-12-25 14:51:39 +00001734 SourceRange(D->getLocStart(),
1735 DIE->getLocEnd()));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001736 assert(StructuredList && "Expected a structured initializer list");
1737 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001738
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001739 if (D->isFieldDesignator()) {
1740 // C99 6.7.8p7:
1741 //
1742 // If a designator has the form
1743 //
1744 // . identifier
1745 //
1746 // then the current object (defined below) shall have
1747 // structure or union type and the identifier shall be the
Mike Stump1eb44332009-09-09 15:08:12 +00001748 // name of a member of that type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001749 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001750 if (!RT) {
1751 SourceLocation Loc = D->getDotLoc();
1752 if (Loc.isInvalid())
1753 Loc = D->getFieldLoc();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001754 if (!VerifyOnly)
1755 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
David Blaikie4e4d0842012-03-11 07:00:24 +00001756 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001757 ++Index;
1758 return true;
1759 }
1760
Douglas Gregor4c678342009-01-28 21:54:33 +00001761 // Note: we perform a linear search of the fields here, despite
1762 // the fact that we have a faster lookup method, because we always
1763 // need to compute the field's index.
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001764 FieldDecl *KnownField = D->getField();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001765 IdentifierInfo *FieldName = D->getFieldName();
Douglas Gregor4c678342009-01-28 21:54:33 +00001766 unsigned FieldIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001767 RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001768 Field = RT->getDecl()->field_begin(),
1769 FieldEnd = RT->getDecl()->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +00001770 for (; Field != FieldEnd; ++Field) {
1771 if (Field->isUnnamedBitfield())
1772 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001773
Francois Picheta0e27f02010-12-22 03:46:10 +00001774 // If we find a field representing an anonymous field, look in the
1775 // IndirectFieldDecl that follow for the designated initializer.
1776 if (!KnownField && Field->isAnonymousStructOrUnion()) {
1777 if (IndirectFieldDecl *IF =
David Blaikie581deb32012-06-06 20:45:41 +00001778 FindIndirectFieldDesignator(*Field, FieldName)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001779 // In verify mode, don't modify the original.
1780 if (VerifyOnly)
1781 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
Francois Picheta0e27f02010-12-22 03:46:10 +00001782 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF);
1783 D = DIE->getDesignator(DesigIdx);
1784 break;
1785 }
1786 }
David Blaikie581deb32012-06-06 20:45:41 +00001787 if (KnownField && KnownField == *Field)
Douglas Gregor022d13d2010-10-08 20:44:28 +00001788 break;
1789 if (FieldName && FieldName == Field->getIdentifier())
Douglas Gregor4c678342009-01-28 21:54:33 +00001790 break;
1791
1792 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001793 }
1794
Douglas Gregor4c678342009-01-28 21:54:33 +00001795 if (Field == FieldEnd) {
Benjamin Kramera41ee492011-09-25 02:41:26 +00001796 if (VerifyOnly) {
1797 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001798 return true; // No typo correction when just trying this out.
Benjamin Kramera41ee492011-09-25 02:41:26 +00001799 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001800
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001801 // There was no normal field in the struct with the designated
1802 // name. Perform another lookup for this name, which may find
1803 // something that we can't designate (e.g., a member function),
1804 // may find nothing, or may find a member of an anonymous
Mike Stump1eb44332009-09-09 15:08:12 +00001805 // struct/union.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001806 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001807 FieldDecl *ReplacementField = 0;
David Blaikie3bc93e32012-12-19 00:45:41 +00001808 if (Lookup.empty()) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001809 // Name lookup didn't find anything. Determine whether this
1810 // was a typo for another field name.
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001811 FieldInitializerValidatorCCC Validator(RT->getDecl());
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001812 TypoCorrection Corrected = SemaRef.CorrectTypo(
1813 DeclarationNameInfo(FieldName, D->getFieldLoc()),
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00001814 Sema::LookupMemberName, /*Scope=*/0, /*SS=*/0, Validator,
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001815 RT->getDecl());
1816 if (Corrected) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001817 std::string CorrectedStr(
David Blaikie4e4d0842012-03-11 07:00:24 +00001818 Corrected.getAsString(SemaRef.getLangOpts()));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001819 std::string CorrectedQuotedStr(
David Blaikie4e4d0842012-03-11 07:00:24 +00001820 Corrected.getQuoted(SemaRef.getLangOpts()));
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001821 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001822 SemaRef.Diag(D->getFieldLoc(),
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001823 diag::err_field_designator_unknown_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001824 << FieldName << CurrentObjectType << CorrectedQuotedStr
1825 << FixItHint::CreateReplacement(D->getFieldLoc(), CorrectedStr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001826 SemaRef.Diag(ReplacementField->getLocation(),
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001827 diag::note_previous_decl) << CorrectedQuotedStr;
Benjamin Kramera41ee492011-09-25 02:41:26 +00001828 hadError = true;
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001829 } else {
1830 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1831 << FieldName << CurrentObjectType;
1832 ++Index;
1833 return true;
1834 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001835 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001836
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001837 if (!ReplacementField) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001838 // Name lookup found something, but it wasn't a field.
Chris Lattner08202542009-02-24 22:50:46 +00001839 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
Douglas Gregor4c678342009-01-28 21:54:33 +00001840 << FieldName;
David Blaikie3bc93e32012-12-19 00:45:41 +00001841 SemaRef.Diag(Lookup.front()->getLocation(),
Douglas Gregor4c678342009-01-28 21:54:33 +00001842 diag::note_field_designator_found);
Eli Friedmanba79fc22009-04-16 17:49:48 +00001843 ++Index;
1844 return true;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001845 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001846
Francois Picheta0e27f02010-12-22 03:46:10 +00001847 if (!KnownField) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001848 // The replacement field comes from typo correction; find it
1849 // in the list of fields.
1850 FieldIndex = 0;
1851 Field = RT->getDecl()->field_begin();
1852 for (; Field != FieldEnd; ++Field) {
1853 if (Field->isUnnamedBitfield())
1854 continue;
1855
David Blaikie581deb32012-06-06 20:45:41 +00001856 if (ReplacementField == *Field ||
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001857 Field->getIdentifier() == ReplacementField->getIdentifier())
1858 break;
1859
1860 ++FieldIndex;
1861 }
1862 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001863 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001864
1865 // All of the fields of a union are located at the same place in
1866 // the initializer list.
Douglas Gregor0bb76892009-01-29 16:53:55 +00001867 if (RT->getDecl()->isUnion()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001868 FieldIndex = 0;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001869 if (!VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001870 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001871 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001872
Douglas Gregor54001c12011-06-29 21:51:31 +00001873 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001874 bool InvalidUse;
1875 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001876 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001877 else
David Blaikie581deb32012-06-06 20:45:41 +00001878 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001879 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001880 ++Index;
1881 return true;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001882 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001883
Sebastian Redl14b0c192011-09-24 17:48:00 +00001884 if (!VerifyOnly) {
1885 // Update the designator with the field declaration.
David Blaikie581deb32012-06-06 20:45:41 +00001886 D->setField(*Field);
Mike Stump1eb44332009-09-09 15:08:12 +00001887
Sebastian Redl14b0c192011-09-24 17:48:00 +00001888 // Make sure that our non-designated initializer list has space
1889 // for a subobject corresponding to this field.
1890 if (FieldIndex >= StructuredList->getNumInits())
1891 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1892 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001893
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001894 // This designator names a flexible array member.
1895 if (Field->getType()->isIncompleteArrayType()) {
1896 bool Invalid = false;
Douglas Gregor71199712009-04-15 04:56:10 +00001897 if ((DesigIdx + 1) != DIE->size()) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001898 // We can't designate an object within the flexible array
1899 // member (because GCC doesn't allow it).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001900 if (!VerifyOnly) {
1901 DesignatedInitExpr::Designator *NextD
1902 = DIE->getDesignator(DesigIdx + 1);
Erik Verbruggen65d78312012-12-25 14:51:39 +00001903 SemaRef.Diag(NextD->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001904 diag::err_designator_into_flexible_array_member)
Erik Verbruggen65d78312012-12-25 14:51:39 +00001905 << SourceRange(NextD->getLocStart(),
1906 DIE->getLocEnd());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001907 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001908 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001909 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001910 Invalid = true;
1911 }
1912
Chris Lattner9046c222010-10-10 17:49:49 +00001913 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
1914 !isa<StringLiteral>(DIE->getInit())) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001915 // The initializer is not an initializer list.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001916 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001917 SemaRef.Diag(DIE->getInit()->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001918 diag::err_flexible_array_init_needs_braces)
1919 << DIE->getInit()->getSourceRange();
1920 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001921 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001922 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001923 Invalid = true;
1924 }
1925
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001926 // Check GNU flexible array initializer.
David Blaikie581deb32012-06-06 20:45:41 +00001927 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001928 TopLevelObject))
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001929 Invalid = true;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001930
1931 if (Invalid) {
1932 ++Index;
1933 return true;
1934 }
1935
1936 // Initialize the array.
1937 bool prevHadError = hadError;
1938 unsigned newStructuredIndex = FieldIndex;
1939 unsigned OldIndex = Index;
1940 IList->setInit(Index, DIE->getInit());
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001941
1942 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001943 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001944 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001945 StructuredList, newStructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001946
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001947 IList->setInit(OldIndex, DIE);
1948 if (hadError && !prevHadError) {
1949 ++Field;
1950 ++FieldIndex;
1951 if (NextField)
1952 *NextField = Field;
1953 StructuredIndex = FieldIndex;
1954 return true;
1955 }
1956 } else {
1957 // Recurse to check later designated subobjects.
David Blaikie262bc182012-04-30 02:36:29 +00001958 QualType FieldType = Field->getType();
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001959 unsigned newStructuredIndex = FieldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001960
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001961 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001962 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001963 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
1964 FieldType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001965 StructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001966 true, false))
1967 return true;
1968 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001969
1970 // Find the position of the next field to be initialized in this
1971 // subobject.
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001972 ++Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001973 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001974
1975 // If this the first designator, our caller will continue checking
1976 // the rest of this struct/class/union subobject.
1977 if (IsFirstDesignator) {
1978 if (NextField)
1979 *NextField = Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001980 StructuredIndex = FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001981 return false;
1982 }
1983
Douglas Gregor34e79462009-01-28 23:36:17 +00001984 if (!FinishSubobjectInit)
1985 return false;
1986
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001987 // We've already initialized something in the union; we're done.
1988 if (RT->getDecl()->isUnion())
1989 return hadError;
1990
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001991 // Check the remaining fields within this class/struct/union subobject.
1992 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001993
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001994 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001995 StructuredList, FieldIndex);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001996 return hadError && !prevHadError;
1997 }
1998
1999 // C99 6.7.8p6:
2000 //
2001 // If a designator has the form
2002 //
2003 // [ constant-expression ]
2004 //
2005 // then the current object (defined below) shall have array
2006 // type and the expression shall be an integer constant
2007 // expression. If the array is of unknown size, any
2008 // nonnegative value is valid.
2009 //
2010 // Additionally, cope with the GNU extension that permits
2011 // designators of the form
2012 //
2013 // [ constant-expression ... constant-expression ]
Chris Lattner08202542009-02-24 22:50:46 +00002014 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002015 if (!AT) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002016 if (!VerifyOnly)
2017 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2018 << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002019 ++Index;
2020 return true;
2021 }
2022
2023 Expr *IndexExpr = 0;
Douglas Gregor34e79462009-01-28 23:36:17 +00002024 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2025 if (D->isArrayDesignator()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002026 IndexExpr = DIE->getArrayIndex(*D);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002027 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor34e79462009-01-28 23:36:17 +00002028 DesignatedEndIndex = DesignatedStartIndex;
2029 } else {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002030 assert(D->isArrayRangeDesignator() && "Need array-range designator");
Douglas Gregor34e79462009-01-28 23:36:17 +00002031
Mike Stump1eb44332009-09-09 15:08:12 +00002032 DesignatedStartIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002033 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
Mike Stump1eb44332009-09-09 15:08:12 +00002034 DesignatedEndIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002035 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002036 IndexExpr = DIE->getArrayRangeEnd(*D);
Douglas Gregor34e79462009-01-28 23:36:17 +00002037
Chris Lattnere0fd8322011-02-19 22:28:58 +00002038 // Codegen can't handle evaluating array range designators that have side
2039 // effects, because we replicate the AST value for each initialized element.
2040 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2041 // elements with something that has a side effect, so codegen can emit an
2042 // "error unsupported" error instead of miscompiling the app.
2043 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
Sebastian Redl14b0c192011-09-24 17:48:00 +00002044 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
Douglas Gregora9c87802009-01-29 19:42:23 +00002045 FullyStructuredList->sawArrayRangeDesignator();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002046 }
2047
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002048 if (isa<ConstantArrayType>(AT)) {
2049 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
Jay Foad9f71a8f2010-12-07 08:25:34 +00002050 DesignatedStartIndex
2051 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002052 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
Jay Foad9f71a8f2010-12-07 08:25:34 +00002053 DesignatedEndIndex
2054 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002055 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2056 if (DesignatedEndIndex >= MaxElements) {
Eli Friedmana4e20e12011-09-26 18:53:43 +00002057 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00002058 SemaRef.Diag(IndexExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00002059 diag::err_array_designator_too_large)
2060 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2061 << IndexExpr->getSourceRange();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002062 ++Index;
2063 return true;
2064 }
Douglas Gregor34e79462009-01-28 23:36:17 +00002065 } else {
2066 // Make sure the bit-widths and signedness match.
2067 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002068 DesignatedEndIndex
2069 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
Chris Lattner3bf68932009-04-25 21:59:05 +00002070 else if (DesignatedStartIndex.getBitWidth() <
2071 DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002072 DesignatedStartIndex
2073 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002074 DesignatedStartIndex.setIsUnsigned(true);
2075 DesignatedEndIndex.setIsUnsigned(true);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002076 }
Mike Stump1eb44332009-09-09 15:08:12 +00002077
Eli Friedman188ddb12013-06-11 21:48:11 +00002078 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2079 // We're modifying a string literal init; we have to decompose the string
2080 // so we can modify the individual characters.
2081 ASTContext &Context = SemaRef.Context;
2082 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2083
2084 // Compute the character type
2085 QualType CharTy = AT->getElementType();
2086
2087 // Compute the type of the integer literals.
2088 QualType PromotedCharTy = CharTy;
2089 if (CharTy->isPromotableIntegerType())
2090 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2091 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2092
2093 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2094 // Get the length of the string.
2095 uint64_t StrLen = SL->getLength();
2096 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2097 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2098 StructuredList->resizeInits(Context, StrLen);
2099
2100 // Build a literal for each character in the string, and put them into
2101 // the init list.
2102 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2103 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2104 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002105 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002106 if (CharTy != PromotedCharTy)
2107 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2108 Init, 0, VK_RValue);
2109 StructuredList->updateInit(Context, i, Init);
2110 }
2111 } else {
2112 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2113 std::string Str;
2114 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2115
2116 // Get the length of the string.
2117 uint64_t StrLen = Str.size();
2118 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2119 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2120 StructuredList->resizeInits(Context, StrLen);
2121
2122 // Build a literal for each character in the string, and put them into
2123 // the init list.
2124 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2125 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2126 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002127 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002128 if (CharTy != PromotedCharTy)
2129 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2130 Init, 0, VK_RValue);
2131 StructuredList->updateInit(Context, i, Init);
2132 }
2133 }
2134 }
2135
Douglas Gregor4c678342009-01-28 21:54:33 +00002136 // Make sure that our non-designated initializer list has space
2137 // for a subobject corresponding to this array element.
Sebastian Redl14b0c192011-09-24 17:48:00 +00002138 if (!VerifyOnly &&
2139 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
Mike Stump1eb44332009-09-09 15:08:12 +00002140 StructuredList->resizeInits(SemaRef.Context,
Douglas Gregor34e79462009-01-28 23:36:17 +00002141 DesignatedEndIndex.getZExtValue() + 1);
Douglas Gregor4c678342009-01-28 21:54:33 +00002142
Douglas Gregor34e79462009-01-28 23:36:17 +00002143 // Repeatedly perform subobject initializations in the range
2144 // [DesignatedStartIndex, DesignatedEndIndex].
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002145
Douglas Gregor34e79462009-01-28 23:36:17 +00002146 // Move to the next designator
2147 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2148 unsigned OldIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002149
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002150 InitializedEntity ElementEntity =
Anders Carlsson8ff9e862010-01-23 23:23:01 +00002151 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002152
Douglas Gregor34e79462009-01-28 23:36:17 +00002153 while (DesignatedStartIndex <= DesignatedEndIndex) {
2154 // Recurse to check later designated subobjects.
2155 QualType ElementType = AT->getElementType();
2156 Index = OldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002157
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002158 ElementEntity.setElementIndex(ElementIndex);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002159 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2160 ElementType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002161 StructuredList, ElementIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00002162 (DesignatedStartIndex == DesignatedEndIndex),
2163 false))
Douglas Gregor34e79462009-01-28 23:36:17 +00002164 return true;
2165
2166 // Move to the next index in the array that we'll be initializing.
2167 ++DesignatedStartIndex;
2168 ElementIndex = DesignatedStartIndex.getZExtValue();
2169 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002170
2171 // If this the first designator, our caller will continue checking
2172 // the rest of this array subobject.
2173 if (IsFirstDesignator) {
2174 if (NextElementIndex)
Douglas Gregor34e79462009-01-28 23:36:17 +00002175 *NextElementIndex = DesignatedStartIndex;
Douglas Gregor4c678342009-01-28 21:54:33 +00002176 StructuredIndex = ElementIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002177 return false;
2178 }
Mike Stump1eb44332009-09-09 15:08:12 +00002179
Douglas Gregor34e79462009-01-28 23:36:17 +00002180 if (!FinishSubobjectInit)
2181 return false;
2182
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002183 // Check the remaining elements within this array subobject.
Douglas Gregor05c13a32009-01-22 00:58:24 +00002184 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002185 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
Anders Carlsson784f6992010-01-23 20:13:41 +00002186 /*SubobjectIsDesignatorContext=*/false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002187 StructuredList, ElementIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002188 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002189}
2190
Douglas Gregor4c678342009-01-28 21:54:33 +00002191// Get the structured initializer list for a subobject of type
2192// @p CurrentObjectType.
2193InitListExpr *
2194InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2195 QualType CurrentObjectType,
2196 InitListExpr *StructuredList,
2197 unsigned StructuredIndex,
2198 SourceRange InitRange) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002199 if (VerifyOnly)
2200 return 0; // No structured list in verification-only mode.
Douglas Gregor4c678342009-01-28 21:54:33 +00002201 Expr *ExistingInit = 0;
2202 if (!StructuredList)
Benjamin Kramera7894162012-02-23 14:48:40 +00002203 ExistingInit = SyntacticToSemantic.lookup(IList);
Douglas Gregor4c678342009-01-28 21:54:33 +00002204 else if (StructuredIndex < StructuredList->getNumInits())
2205 ExistingInit = StructuredList->getInit(StructuredIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002206
Douglas Gregor4c678342009-01-28 21:54:33 +00002207 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2208 return Result;
2209
2210 if (ExistingInit) {
2211 // We are creating an initializer list that initializes the
2212 // subobjects of the current object, but there was already an
2213 // initialization that completely initialized the current
2214 // subobject, e.g., by a compound literal:
Mike Stump1eb44332009-09-09 15:08:12 +00002215 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002216 // struct X { int a, b; };
2217 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
Mike Stump1eb44332009-09-09 15:08:12 +00002218 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002219 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2220 // designated initializer re-initializes the whole
2221 // subobject [0], overwriting previous initializers.
Mike Stump1eb44332009-09-09 15:08:12 +00002222 SemaRef.Diag(InitRange.getBegin(),
Douglas Gregored8a93d2009-03-01 17:12:46 +00002223 diag::warn_subobject_initializer_overrides)
Douglas Gregor4c678342009-01-28 21:54:33 +00002224 << InitRange;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002225 SemaRef.Diag(ExistingInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002226 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002227 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002228 << ExistingInit->getSourceRange();
2229 }
2230
Mike Stump1eb44332009-09-09 15:08:12 +00002231 InitListExpr *Result
Ted Kremenek709210f2010-04-13 23:39:13 +00002232 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00002233 InitRange.getBegin(), None,
Ted Kremenekba7bc552010-02-19 01:50:18 +00002234 InitRange.getEnd());
Douglas Gregored8a93d2009-03-01 17:12:46 +00002235
Eli Friedman5c89c392012-02-23 02:25:10 +00002236 QualType ResultType = CurrentObjectType;
2237 if (!ResultType->isArrayType())
2238 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2239 Result->setType(ResultType);
Douglas Gregor4c678342009-01-28 21:54:33 +00002240
Douglas Gregorfa219202009-03-20 23:58:33 +00002241 // Pre-allocate storage for the structured initializer list.
2242 unsigned NumElements = 0;
Douglas Gregor08457732009-03-21 18:13:52 +00002243 unsigned NumInits = 0;
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002244 bool GotNumInits = false;
2245 if (!StructuredList) {
Douglas Gregor08457732009-03-21 18:13:52 +00002246 NumInits = IList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002247 GotNumInits = true;
2248 } else if (Index < IList->getNumInits()) {
2249 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
Douglas Gregor08457732009-03-21 18:13:52 +00002250 NumInits = SubList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002251 GotNumInits = true;
2252 }
Douglas Gregor08457732009-03-21 18:13:52 +00002253 }
2254
Mike Stump1eb44332009-09-09 15:08:12 +00002255 if (const ArrayType *AType
Douglas Gregorfa219202009-03-20 23:58:33 +00002256 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2257 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2258 NumElements = CAType->getSize().getZExtValue();
2259 // Simple heuristic so that we don't allocate a very large
2260 // initializer with many empty entries at the end.
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002261 if (GotNumInits && NumElements > NumInits)
Douglas Gregorfa219202009-03-20 23:58:33 +00002262 NumElements = 0;
2263 }
John McCall183700f2009-09-21 23:43:11 +00002264 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
Douglas Gregorfa219202009-03-20 23:58:33 +00002265 NumElements = VType->getNumElements();
Ted Kremenek6217b802009-07-29 21:53:49 +00002266 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
Douglas Gregorfa219202009-03-20 23:58:33 +00002267 RecordDecl *RDecl = RType->getDecl();
2268 if (RDecl->isUnion())
2269 NumElements = 1;
2270 else
Mike Stump1eb44332009-09-09 15:08:12 +00002271 NumElements = std::distance(RDecl->field_begin(),
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002272 RDecl->field_end());
Douglas Gregorfa219202009-03-20 23:58:33 +00002273 }
2274
Ted Kremenek709210f2010-04-13 23:39:13 +00002275 Result->reserveInits(SemaRef.Context, NumElements);
Douglas Gregorfa219202009-03-20 23:58:33 +00002276
Douglas Gregor4c678342009-01-28 21:54:33 +00002277 // Link this new initializer list into the structured initializer
2278 // lists.
2279 if (StructuredList)
Ted Kremenek709210f2010-04-13 23:39:13 +00002280 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
Douglas Gregor4c678342009-01-28 21:54:33 +00002281 else {
2282 Result->setSyntacticForm(IList);
2283 SyntacticToSemantic[IList] = Result;
2284 }
2285
2286 return Result;
2287}
2288
2289/// Update the initializer at index @p StructuredIndex within the
2290/// structured initializer list to the value @p expr.
2291void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2292 unsigned &StructuredIndex,
2293 Expr *expr) {
2294 // No structured initializer list to update
2295 if (!StructuredList)
2296 return;
2297
Ted Kremenek709210f2010-04-13 23:39:13 +00002298 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2299 StructuredIndex, expr)) {
Douglas Gregor4c678342009-01-28 21:54:33 +00002300 // This initializer overwrites a previous initializer. Warn.
Daniel Dunbar96a00142012-03-09 18:35:03 +00002301 SemaRef.Diag(expr->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002302 diag::warn_initializer_overrides)
2303 << expr->getSourceRange();
Daniel Dunbar96a00142012-03-09 18:35:03 +00002304 SemaRef.Diag(PrevInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002305 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002306 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002307 << PrevInit->getSourceRange();
2308 }
Mike Stump1eb44332009-09-09 15:08:12 +00002309
Douglas Gregor4c678342009-01-28 21:54:33 +00002310 ++StructuredIndex;
2311}
2312
Douglas Gregor05c13a32009-01-22 00:58:24 +00002313/// Check that the given Index expression is a valid array designator
Richard Smith282e7e62012-02-04 09:53:13 +00002314/// value. This is essentially just a wrapper around
Chris Lattner3bf68932009-04-25 21:59:05 +00002315/// VerifyIntegerConstantExpression that also checks for negative values
Douglas Gregor05c13a32009-01-22 00:58:24 +00002316/// and produces a reasonable diagnostic if there is a
Richard Smith282e7e62012-02-04 09:53:13 +00002317/// failure. Returns the index expression, possibly with an implicit cast
2318/// added, on success. If everything went okay, Value will receive the
2319/// value of the constant expression.
2320static ExprResult
Chris Lattner3bf68932009-04-25 21:59:05 +00002321CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00002322 SourceLocation Loc = Index->getLocStart();
Douglas Gregor05c13a32009-01-22 00:58:24 +00002323
2324 // Make sure this is an integer constant expression.
Richard Smith282e7e62012-02-04 09:53:13 +00002325 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2326 if (Result.isInvalid())
2327 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002328
Chris Lattner3bf68932009-04-25 21:59:05 +00002329 if (Value.isSigned() && Value.isNegative())
2330 return S.Diag(Loc, diag::err_array_designator_negative)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002331 << Value.toString(10) << Index->getSourceRange();
2332
Douglas Gregor53d3d8e2009-01-23 21:04:18 +00002333 Value.setIsUnsigned(true);
Richard Smith282e7e62012-02-04 09:53:13 +00002334 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002335}
2336
John McCall60d7b3a2010-08-24 06:29:42 +00002337ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
Nick Lewycky7663f392010-11-20 01:29:55 +00002338 SourceLocation Loc,
2339 bool GNUSyntax,
2340 ExprResult Init) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00002341 typedef DesignatedInitExpr::Designator ASTDesignator;
2342
2343 bool Invalid = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002344 SmallVector<ASTDesignator, 32> Designators;
2345 SmallVector<Expr *, 32> InitExpressions;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002346
2347 // Build designators and check array designator expressions.
2348 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2349 const Designator &D = Desig.getDesignator(Idx);
2350 switch (D.getKind()) {
2351 case Designator::FieldDesignator:
Mike Stump1eb44332009-09-09 15:08:12 +00002352 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002353 D.getFieldLoc()));
2354 break;
2355
2356 case Designator::ArrayDesignator: {
2357 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2358 llvm::APSInt IndexValue;
Richard Smith282e7e62012-02-04 09:53:13 +00002359 if (!Index->isTypeDependent() && !Index->isValueDependent())
2360 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take();
2361 if (!Index)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002362 Invalid = true;
2363 else {
2364 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002365 D.getLBracketLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002366 D.getRBracketLoc()));
2367 InitExpressions.push_back(Index);
2368 }
2369 break;
2370 }
2371
2372 case Designator::ArrayRangeDesignator: {
2373 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2374 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2375 llvm::APSInt StartValue;
2376 llvm::APSInt EndValue;
Douglas Gregor9ea62762009-05-21 23:17:49 +00002377 bool StartDependent = StartIndex->isTypeDependent() ||
2378 StartIndex->isValueDependent();
2379 bool EndDependent = EndIndex->isTypeDependent() ||
2380 EndIndex->isValueDependent();
Richard Smith282e7e62012-02-04 09:53:13 +00002381 if (!StartDependent)
2382 StartIndex =
2383 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take();
2384 if (!EndDependent)
2385 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take();
2386
2387 if (!StartIndex || !EndIndex)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002388 Invalid = true;
Douglas Gregord6f584f2009-01-23 22:22:29 +00002389 else {
2390 // Make sure we're comparing values with the same bit width.
Douglas Gregor9ea62762009-05-21 23:17:49 +00002391 if (StartDependent || EndDependent) {
2392 // Nothing to compute.
2393 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002394 EndValue = EndValue.extend(StartValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002395 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002396 StartValue = StartValue.extend(EndValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002397
Douglas Gregorc4bb7bf2009-05-21 23:30:39 +00002398 if (!StartDependent && !EndDependent && EndValue < StartValue) {
Douglas Gregord6f584f2009-01-23 22:22:29 +00002399 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
Mike Stump1eb44332009-09-09 15:08:12 +00002400 << StartValue.toString(10) << EndValue.toString(10)
Douglas Gregord6f584f2009-01-23 22:22:29 +00002401 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2402 Invalid = true;
2403 } else {
2404 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002405 D.getLBracketLoc(),
Douglas Gregord6f584f2009-01-23 22:22:29 +00002406 D.getEllipsisLoc(),
2407 D.getRBracketLoc()));
2408 InitExpressions.push_back(StartIndex);
2409 InitExpressions.push_back(EndIndex);
2410 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00002411 }
2412 break;
2413 }
2414 }
2415 }
2416
2417 if (Invalid || Init.isInvalid())
2418 return ExprError();
2419
2420 // Clear out the expressions within the designation.
2421 Desig.ClearExprs(*this);
2422
2423 DesignatedInitExpr *DIE
Jay Foadbeaaccd2009-05-21 09:52:38 +00002424 = DesignatedInitExpr::Create(Context,
2425 Designators.data(), Designators.size(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00002426 InitExpressions, Loc, GNUSyntax,
2427 Init.takeAs<Expr>());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002428
David Blaikie4e4d0842012-03-11 07:00:24 +00002429 if (!getLangOpts().C99)
Douglas Gregor2d75bbd2011-01-16 16:13:16 +00002430 Diag(DIE->getLocStart(), diag::ext_designated_init)
2431 << DIE->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002432
Douglas Gregor05c13a32009-01-22 00:58:24 +00002433 return Owned(DIE);
2434}
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002435
Douglas Gregor20093b42009-12-09 23:02:17 +00002436//===----------------------------------------------------------------------===//
2437// Initialization entity
2438//===----------------------------------------------------------------------===//
2439
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002440InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002441 const InitializedEntity &Parent)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002442 : Parent(&Parent), Index(Index)
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002443{
Anders Carlssond3d824d2010-01-23 04:34:47 +00002444 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2445 Kind = EK_ArrayElement;
Douglas Gregord6542d82009-12-22 15:35:07 +00002446 Type = AT->getElementType();
Eli Friedman0c706c22011-09-19 23:17:44 +00002447 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
Anders Carlssond3d824d2010-01-23 04:34:47 +00002448 Kind = EK_VectorElement;
Eli Friedman0c706c22011-09-19 23:17:44 +00002449 Type = VT->getElementType();
2450 } else {
2451 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2452 assert(CT && "Unexpected type");
2453 Kind = EK_ComplexElement;
2454 Type = CT->getElementType();
Anders Carlssond3d824d2010-01-23 04:34:47 +00002455 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002456}
2457
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002458InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context,
Anders Carlsson711f34a2010-04-21 19:52:01 +00002459 CXXBaseSpecifier *Base,
2460 bool IsInheritedVirtualBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00002461{
2462 InitializedEntity Result;
2463 Result.Kind = EK_Base;
Richard Smitha4bb99c2013-06-12 21:51:50 +00002464 Result.Parent = 0;
Anders Carlsson711f34a2010-04-21 19:52:01 +00002465 Result.Base = reinterpret_cast<uintptr_t>(Base);
2466 if (IsInheritedVirtualBase)
2467 Result.Base |= 0x01;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002468
Douglas Gregord6542d82009-12-22 15:35:07 +00002469 Result.Type = Base->getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00002470 return Result;
2471}
2472
Douglas Gregor99a2e602009-12-16 01:38:02 +00002473DeclarationName InitializedEntity::getName() const {
2474 switch (getKind()) {
John McCallf85e1932011-06-15 23:02:42 +00002475 case EK_Parameter: {
2476 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2477 return (D ? D->getDeclName() : DeclarationName());
2478 }
Douglas Gregora188ff22009-12-22 16:09:06 +00002479
2480 case EK_Variable:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002481 case EK_Member:
2482 return VariableOrMember->getDeclName();
2483
Douglas Gregor47736542012-02-15 16:57:26 +00002484 case EK_LambdaCapture:
2485 return Capture.Var->getDeclName();
2486
Douglas Gregor99a2e602009-12-16 01:38:02 +00002487 case EK_Result:
2488 case EK_Exception:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002489 case EK_New:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002490 case EK_Temporary:
2491 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002492 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002493 case EK_ArrayElement:
2494 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002495 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002496 case EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00002497 case EK_CompoundLiteralInit:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002498 return DeclarationName();
2499 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002500
David Blaikie7530c032012-01-17 06:56:22 +00002501 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor99a2e602009-12-16 01:38:02 +00002502}
2503
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002504DeclaratorDecl *InitializedEntity::getDecl() const {
2505 switch (getKind()) {
2506 case EK_Variable:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002507 case EK_Member:
2508 return VariableOrMember;
2509
John McCallf85e1932011-06-15 23:02:42 +00002510 case EK_Parameter:
2511 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2512
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002513 case EK_Result:
2514 case EK_Exception:
2515 case EK_New:
2516 case EK_Temporary:
2517 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002518 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002519 case EK_ArrayElement:
2520 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002521 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002522 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002523 case EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00002524 case EK_CompoundLiteralInit:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002525 return 0;
2526 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002527
David Blaikie7530c032012-01-17 06:56:22 +00002528 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002529}
2530
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002531bool InitializedEntity::allowsNRVO() const {
2532 switch (getKind()) {
2533 case EK_Result:
2534 case EK_Exception:
2535 return LocAndNRVO.NRVO;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002536
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002537 case EK_Variable:
2538 case EK_Parameter:
2539 case EK_Member:
2540 case EK_New:
2541 case EK_Temporary:
Jordan Rose2624b812013-05-06 16:48:12 +00002542 case EK_CompoundLiteralInit:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002543 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002544 case EK_Delegating:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002545 case EK_ArrayElement:
2546 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002547 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002548 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002549 case EK_LambdaCapture:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002550 break;
2551 }
2552
2553 return false;
2554}
2555
Richard Smith211c8dd2013-06-05 00:46:14 +00002556unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
Richard Smitha4bb99c2013-06-12 21:51:50 +00002557 assert(getParent() != this);
Richard Smith211c8dd2013-06-05 00:46:14 +00002558 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2559 for (unsigned I = 0; I != Depth; ++I)
2560 OS << "`-";
2561
2562 switch (getKind()) {
2563 case EK_Variable: OS << "Variable"; break;
2564 case EK_Parameter: OS << "Parameter"; break;
2565 case EK_Result: OS << "Result"; break;
2566 case EK_Exception: OS << "Exception"; break;
2567 case EK_Member: OS << "Member"; break;
2568 case EK_New: OS << "New"; break;
2569 case EK_Temporary: OS << "Temporary"; break;
2570 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2571 case EK_Base: OS << "Base"; break;
2572 case EK_Delegating: OS << "Delegating"; break;
2573 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2574 case EK_VectorElement: OS << "VectorElement " << Index; break;
2575 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2576 case EK_BlockElement: OS << "Block"; break;
2577 case EK_LambdaCapture:
2578 OS << "LambdaCapture ";
2579 getCapturedVar()->printName(OS);
2580 break;
2581 }
2582
2583 if (Decl *D = getDecl()) {
2584 OS << " ";
2585 cast<NamedDecl>(D)->printQualifiedName(OS);
2586 }
2587
2588 OS << " '" << getType().getAsString() << "'\n";
2589
2590 return Depth + 1;
2591}
2592
2593void InitializedEntity::dump() const {
2594 dumpImpl(llvm::errs());
2595}
2596
Douglas Gregor20093b42009-12-09 23:02:17 +00002597//===----------------------------------------------------------------------===//
2598// Initialization sequence
2599//===----------------------------------------------------------------------===//
2600
2601void InitializationSequence::Step::Destroy() {
2602 switch (Kind) {
2603 case SK_ResolveAddressOfOverloadedFunction:
2604 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002605 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002606 case SK_CastDerivedToBaseLValue:
2607 case SK_BindReference:
2608 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00002609 case SK_ExtraneousCopyToTemporary:
Douglas Gregor20093b42009-12-09 23:02:17 +00002610 case SK_UserConversion:
2611 case SK_QualificationConversionRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002612 case SK_QualificationConversionXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002613 case SK_QualificationConversionLValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00002614 case SK_LValueToRValue:
Douglas Gregord87b61f2009-12-10 17:56:55 +00002615 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002616 case SK_ListConstructorCall:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002617 case SK_UnwrapInitList:
2618 case SK_RewrapInitList:
Douglas Gregor51c56d62009-12-14 20:49:26 +00002619 case SK_ConstructorInitialization:
Douglas Gregor71d17402009-12-15 00:01:57 +00002620 case SK_ZeroInitialization:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002621 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002622 case SK_StringInit:
Douglas Gregor569c3162010-08-07 11:51:51 +00002623 case SK_ObjCObjectConversion:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002624 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00002625 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00002626 case SK_PassByIndirectCopyRestore:
2627 case SK_PassByIndirectRestore:
2628 case SK_ProduceObjCObject:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002629 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00002630 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00002631 case SK_OCLZeroEvent:
Douglas Gregor20093b42009-12-09 23:02:17 +00002632 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002633
Douglas Gregor20093b42009-12-09 23:02:17 +00002634 case SK_ConversionSequence:
2635 delete ICS;
2636 }
2637}
2638
Douglas Gregorb70cf442010-03-26 20:14:36 +00002639bool InitializationSequence::isDirectReferenceBinding() const {
Sebastian Redl3b802322011-07-14 19:07:55 +00002640 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
Douglas Gregorb70cf442010-03-26 20:14:36 +00002641}
2642
2643bool InitializationSequence::isAmbiguous() const {
Sebastian Redld695d6b2011-06-05 13:59:05 +00002644 if (!Failed())
Douglas Gregorb70cf442010-03-26 20:14:36 +00002645 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002646
Douglas Gregorb70cf442010-03-26 20:14:36 +00002647 switch (getFailureKind()) {
2648 case FK_TooManyInitsForReference:
2649 case FK_ArrayNeedsInitList:
2650 case FK_ArrayNeedsInitListOrStringLiteral:
Hans Wennborg0ff50742013-05-15 11:03:04 +00002651 case FK_ArrayNeedsInitListOrWideStringLiteral:
2652 case FK_NarrowStringIntoWideCharArray:
2653 case FK_WideStringIntoCharArray:
2654 case FK_IncompatWideStringIntoWideChar:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002655 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2656 case FK_NonConstLValueReferenceBindingToTemporary:
2657 case FK_NonConstLValueReferenceBindingToUnrelated:
2658 case FK_RValueReferenceBindingToLValue:
2659 case FK_ReferenceInitDropsQualifiers:
2660 case FK_ReferenceInitFailed:
2661 case FK_ConversionFailed:
John Wiegley429bb272011-04-08 18:41:53 +00002662 case FK_ConversionFromPropertyFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002663 case FK_TooManyInitsForScalar:
2664 case FK_ReferenceBindingToInitList:
2665 case FK_InitListBadDestinationType:
2666 case FK_DefaultInitOfConst:
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002667 case FK_Incomplete:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002668 case FK_ArrayTypeMismatch:
2669 case FK_NonConstantArrayInit:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002670 case FK_ListInitializationFailed:
John McCall73076432012-01-05 00:13:19 +00002671 case FK_VariableLengthArrayHasInitializer:
John McCall5acb0c92011-10-17 18:40:02 +00002672 case FK_PlaceholderType:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002673 case FK_InitListElementCopyFailure:
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002674 case FK_ExplicitConstructor:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002675 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002676
Douglas Gregorb70cf442010-03-26 20:14:36 +00002677 case FK_ReferenceInitOverloadFailed:
2678 case FK_UserConversionOverloadFailed:
2679 case FK_ConstructorOverloadFailed:
Sebastian Redlcf15cef2011-12-22 18:58:38 +00002680 case FK_ListConstructorOverloadFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002681 return FailedOverloadResult == OR_Ambiguous;
2682 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002683
David Blaikie7530c032012-01-17 06:56:22 +00002684 llvm_unreachable("Invalid EntityKind!");
Douglas Gregorb70cf442010-03-26 20:14:36 +00002685}
2686
Douglas Gregord6e44a32010-04-16 22:09:46 +00002687bool InitializationSequence::isConstructorInitialization() const {
2688 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2689}
2690
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002691void
2692InitializationSequence
2693::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2694 DeclAccessPair Found,
2695 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002696 Step S;
2697 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2698 S.Type = Function->getType();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002699 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002700 S.Function.Function = Function;
John McCall6bb80172010-03-30 21:47:33 +00002701 S.Function.FoundDecl = Found;
Douglas Gregor20093b42009-12-09 23:02:17 +00002702 Steps.push_back(S);
2703}
2704
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002705void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00002706 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002707 Step S;
John McCall5baba9d2010-08-25 10:28:54 +00002708 switch (VK) {
2709 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2710 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2711 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002712 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002713 S.Type = BaseType;
2714 Steps.push_back(S);
2715}
2716
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002717void InitializationSequence::AddReferenceBindingStep(QualType T,
Douglas Gregor20093b42009-12-09 23:02:17 +00002718 bool BindingTemporary) {
2719 Step S;
2720 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2721 S.Type = T;
2722 Steps.push_back(S);
2723}
2724
Douglas Gregor523d46a2010-04-18 07:40:54 +00002725void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2726 Step S;
2727 S.Kind = SK_ExtraneousCopyToTemporary;
2728 S.Type = T;
2729 Steps.push_back(S);
2730}
2731
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002732void
2733InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2734 DeclAccessPair FoundDecl,
2735 QualType T,
2736 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002737 Step S;
2738 S.Kind = SK_UserConversion;
Eli Friedman03981012009-12-11 02:42:07 +00002739 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002740 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002741 S.Function.Function = Function;
2742 S.Function.FoundDecl = FoundDecl;
Douglas Gregor20093b42009-12-09 23:02:17 +00002743 Steps.push_back(S);
2744}
2745
2746void InitializationSequence::AddQualificationConversionStep(QualType Ty,
John McCall5baba9d2010-08-25 10:28:54 +00002747 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002748 Step S;
John McCall38a4ffe2010-08-26 16:36:35 +00002749 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
John McCall5baba9d2010-08-25 10:28:54 +00002750 switch (VK) {
2751 case VK_RValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002752 S.Kind = SK_QualificationConversionRValue;
2753 break;
John McCall5baba9d2010-08-25 10:28:54 +00002754 case VK_XValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002755 S.Kind = SK_QualificationConversionXValue;
2756 break;
John McCall5baba9d2010-08-25 10:28:54 +00002757 case VK_LValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002758 S.Kind = SK_QualificationConversionLValue;
2759 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002760 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002761 S.Type = Ty;
2762 Steps.push_back(S);
2763}
2764
Jordan Rose1fd1e282013-04-11 00:58:58 +00002765void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
2766 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
2767
2768 Step S;
2769 S.Kind = SK_LValueToRValue;
2770 S.Type = Ty;
2771 Steps.push_back(S);
2772}
2773
Douglas Gregor20093b42009-12-09 23:02:17 +00002774void InitializationSequence::AddConversionSequenceStep(
2775 const ImplicitConversionSequence &ICS,
2776 QualType T) {
2777 Step S;
2778 S.Kind = SK_ConversionSequence;
2779 S.Type = T;
2780 S.ICS = new ImplicitConversionSequence(ICS);
2781 Steps.push_back(S);
2782}
2783
Douglas Gregord87b61f2009-12-10 17:56:55 +00002784void InitializationSequence::AddListInitializationStep(QualType T) {
2785 Step S;
2786 S.Kind = SK_ListInitialization;
2787 S.Type = T;
2788 Steps.push_back(S);
2789}
2790
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002791void
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002792InitializationSequence
2793::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2794 AccessSpecifier Access,
2795 QualType T,
Sebastian Redl10f04a62011-12-22 14:44:04 +00002796 bool HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002797 bool FromInitList, bool AsInitList) {
Douglas Gregor51c56d62009-12-14 20:49:26 +00002798 Step S;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002799 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall
2800 : SK_ConstructorInitialization;
Douglas Gregor51c56d62009-12-14 20:49:26 +00002801 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002802 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002803 S.Function.Function = Constructor;
2804 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
Douglas Gregor51c56d62009-12-14 20:49:26 +00002805 Steps.push_back(S);
2806}
2807
Douglas Gregor71d17402009-12-15 00:01:57 +00002808void InitializationSequence::AddZeroInitializationStep(QualType T) {
2809 Step S;
2810 S.Kind = SK_ZeroInitialization;
2811 S.Type = T;
2812 Steps.push_back(S);
2813}
2814
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002815void InitializationSequence::AddCAssignmentStep(QualType T) {
2816 Step S;
2817 S.Kind = SK_CAssignment;
2818 S.Type = T;
2819 Steps.push_back(S);
2820}
2821
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002822void InitializationSequence::AddStringInitStep(QualType T) {
2823 Step S;
2824 S.Kind = SK_StringInit;
2825 S.Type = T;
2826 Steps.push_back(S);
2827}
2828
Douglas Gregor569c3162010-08-07 11:51:51 +00002829void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2830 Step S;
2831 S.Kind = SK_ObjCObjectConversion;
2832 S.Type = T;
2833 Steps.push_back(S);
2834}
2835
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002836void InitializationSequence::AddArrayInitStep(QualType T) {
2837 Step S;
2838 S.Kind = SK_ArrayInit;
2839 S.Type = T;
2840 Steps.push_back(S);
2841}
2842
Richard Smith0f163e92012-02-15 22:38:09 +00002843void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2844 Step S;
2845 S.Kind = SK_ParenthesizedArrayInit;
2846 S.Type = T;
2847 Steps.push_back(S);
2848}
2849
John McCallf85e1932011-06-15 23:02:42 +00002850void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2851 bool shouldCopy) {
2852 Step s;
2853 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2854 : SK_PassByIndirectRestore);
2855 s.Type = type;
2856 Steps.push_back(s);
2857}
2858
2859void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2860 Step S;
2861 S.Kind = SK_ProduceObjCObject;
2862 S.Type = T;
2863 Steps.push_back(S);
2864}
2865
Sebastian Redl2b916b82012-01-17 22:49:42 +00002866void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2867 Step S;
2868 S.Kind = SK_StdInitializerList;
2869 S.Type = T;
2870 Steps.push_back(S);
2871}
2872
Guy Benyei21f18c42013-02-07 10:55:47 +00002873void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
2874 Step S;
2875 S.Kind = SK_OCLSamplerInit;
2876 S.Type = T;
2877 Steps.push_back(S);
2878}
2879
Guy Benyeie6b9d802013-01-20 12:31:11 +00002880void InitializationSequence::AddOCLZeroEventStep(QualType T) {
2881 Step S;
2882 S.Kind = SK_OCLZeroEvent;
2883 S.Type = T;
2884 Steps.push_back(S);
2885}
2886
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002887void InitializationSequence::RewrapReferenceInitList(QualType T,
2888 InitListExpr *Syntactic) {
2889 assert(Syntactic->getNumInits() == 1 &&
2890 "Can only rewrap trivial init lists.");
2891 Step S;
2892 S.Kind = SK_UnwrapInitList;
2893 S.Type = Syntactic->getInit(0)->getType();
2894 Steps.insert(Steps.begin(), S);
2895
2896 S.Kind = SK_RewrapInitList;
2897 S.Type = T;
2898 S.WrappingSyntacticList = Syntactic;
2899 Steps.push_back(S);
2900}
2901
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002902void InitializationSequence::SetOverloadFailure(FailureKind Failure,
Douglas Gregor20093b42009-12-09 23:02:17 +00002903 OverloadingResult Result) {
Sebastian Redl7491c492011-06-05 13:59:11 +00002904 setSequenceKind(FailedSequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00002905 this->Failure = Failure;
2906 this->FailedOverloadResult = Result;
2907}
2908
2909//===----------------------------------------------------------------------===//
2910// Attempt initialization
2911//===----------------------------------------------------------------------===//
2912
John McCallf85e1932011-06-15 23:02:42 +00002913static void MaybeProduceObjCObject(Sema &S,
2914 InitializationSequence &Sequence,
2915 const InitializedEntity &Entity) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002916 if (!S.getLangOpts().ObjCAutoRefCount) return;
John McCallf85e1932011-06-15 23:02:42 +00002917
2918 /// When initializing a parameter, produce the value if it's marked
2919 /// __attribute__((ns_consumed)).
2920 if (Entity.getKind() == InitializedEntity::EK_Parameter) {
2921 if (!Entity.isParameterConsumed())
2922 return;
2923
2924 assert(Entity.getType()->isObjCRetainableType() &&
2925 "consuming an object of unretainable type?");
2926 Sequence.AddProduceObjCObjectStep(Entity.getType());
2927
2928 /// When initializing a return value, if the return type is a
2929 /// retainable type, then returns need to immediately retain the
2930 /// object. If an autorelease is required, it will be done at the
2931 /// last instant.
2932 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
2933 if (!Entity.getType()->isObjCRetainableType())
2934 return;
2935
2936 Sequence.AddProduceObjCObjectStep(Entity.getType());
2937 }
2938}
2939
Richard Smithf4bb8d02012-07-05 08:39:21 +00002940/// \brief When initializing from init list via constructor, handle
2941/// initialization of an object of type std::initializer_list<T>.
Sebastian Redl10f04a62011-12-22 14:44:04 +00002942///
Richard Smithf4bb8d02012-07-05 08:39:21 +00002943/// \return true if we have handled initialization of an object of type
2944/// std::initializer_list<T>, false otherwise.
2945static bool TryInitializerListConstruction(Sema &S,
2946 InitListExpr *List,
2947 QualType DestType,
2948 InitializationSequence &Sequence) {
2949 QualType E;
2950 if (!S.isStdInitializerList(DestType, &E))
Richard Smith1d0c9a82012-02-14 21:14:13 +00002951 return false;
2952
Richard Smithf4bb8d02012-07-05 08:39:21 +00002953 // Check that each individual element can be copy-constructed. But since we
2954 // have no place to store further information, we'll recalculate everything
2955 // later.
2956 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
2957 S.Context.getConstantArrayType(E,
2958 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
2959 List->getNumInits()),
2960 ArrayType::Normal, 0));
2961 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context,
2962 0, HiddenArray);
2963 for (unsigned i = 0, n = List->getNumInits(); i < n; ++i) {
2964 Element.setElementIndex(i);
2965 if (!S.CanPerformCopyInitialization(Element, List->getInit(i))) {
2966 Sequence.SetFailed(
2967 InitializationSequence::FK_InitListElementCopyFailure);
Sebastian Redl10f04a62011-12-22 14:44:04 +00002968 return true;
2969 }
2970 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00002971 Sequence.AddStdInitializerListConstructionStep(DestType);
2972 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002973}
2974
Sebastian Redl96715b22012-02-04 21:27:39 +00002975static OverloadingResult
2976ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00002977 MultiExprArg Args,
Sebastian Redl96715b22012-02-04 21:27:39 +00002978 OverloadCandidateSet &CandidateSet,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002979 ArrayRef<NamedDecl *> Ctors,
Sebastian Redl96715b22012-02-04 21:27:39 +00002980 OverloadCandidateSet::iterator &Best,
2981 bool CopyInitializing, bool AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00002982 bool OnlyListConstructors, bool InitListSyntax) {
Sebastian Redl96715b22012-02-04 21:27:39 +00002983 CandidateSet.clear();
2984
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002985 for (ArrayRef<NamedDecl *>::iterator
2986 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
Sebastian Redl96715b22012-02-04 21:27:39 +00002987 NamedDecl *D = *Con;
2988 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
2989 bool SuppressUserConversions = false;
2990
2991 // Find the constructor (which may be a template).
2992 CXXConstructorDecl *Constructor = 0;
2993 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
2994 if (ConstructorTmpl)
2995 Constructor = cast<CXXConstructorDecl>(
2996 ConstructorTmpl->getTemplatedDecl());
2997 else {
2998 Constructor = cast<CXXConstructorDecl>(D);
2999
3000 // If we're performing copy initialization using a copy constructor, we
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003001 // suppress user-defined conversions on the arguments. We do the same for
3002 // move constructors.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003003 if ((CopyInitializing || (InitListSyntax && Args.size() == 1)) &&
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003004 Constructor->isCopyOrMoveConstructor())
Sebastian Redl96715b22012-02-04 21:27:39 +00003005 SuppressUserConversions = true;
3006 }
3007
3008 if (!Constructor->isInvalidDecl() &&
3009 (AllowExplicit || !Constructor->isExplicit()) &&
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003010 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003011 if (ConstructorTmpl)
3012 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003013 /*ExplicitArgs*/ 0, Args,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003014 CandidateSet, SuppressUserConversions);
Douglas Gregored878af2012-02-24 23:56:31 +00003015 else {
3016 // C++ [over.match.copy]p1:
3017 // - When initializing a temporary to be bound to the first parameter
3018 // of a constructor that takes a reference to possibly cv-qualified
3019 // T as its first argument, called with a single argument in the
3020 // context of direct-initialization, explicit conversion functions
3021 // are also considered.
3022 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003023 Args.size() == 1 &&
Douglas Gregored878af2012-02-24 23:56:31 +00003024 Constructor->isCopyOrMoveConstructor();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003025 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
Douglas Gregored878af2012-02-24 23:56:31 +00003026 SuppressUserConversions,
3027 /*PartialOverloading=*/false,
3028 /*AllowExplicit=*/AllowExplicitConv);
3029 }
Sebastian Redl96715b22012-02-04 21:27:39 +00003030 }
3031 }
3032
3033 // Perform overload resolution and return the result.
3034 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3035}
3036
Sebastian Redl10f04a62011-12-22 14:44:04 +00003037/// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3038/// enumerates the constructors of the initialized entity and performs overload
3039/// resolution to select the best.
Sebastian Redl08ae3692012-02-04 21:27:33 +00003040/// If InitListSyntax is true, this is list-initialization of a non-aggregate
Sebastian Redl10f04a62011-12-22 14:44:04 +00003041/// class type.
3042static void TryConstructorInitialization(Sema &S,
3043 const InitializedEntity &Entity,
3044 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003045 MultiExprArg Args, QualType DestType,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003046 InitializationSequence &Sequence,
Sebastian Redl08ae3692012-02-04 21:27:33 +00003047 bool InitListSyntax = false) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003048 assert((!InitListSyntax || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
Sebastian Redl08ae3692012-02-04 21:27:33 +00003049 "InitListSyntax must come with a single initializer list argument.");
3050
Sebastian Redl10f04a62011-12-22 14:44:04 +00003051 // The type we're constructing needs to be complete.
3052 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003053 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redl96715b22012-02-04 21:27:39 +00003054 return;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003055 }
3056
3057 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3058 assert(DestRecordType && "Constructor initialization requires record type");
3059 CXXRecordDecl *DestRecordDecl
3060 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3061
Sebastian Redl96715b22012-02-04 21:27:39 +00003062 // Build the candidate set directly in the initialization sequence
3063 // structure, so that it will persist if we fail.
3064 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3065
3066 // Determine whether we are allowed to call explicit constructors or
3067 // explicit conversion operators.
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003068 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003069 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
Sebastian Redl08ae3692012-02-04 21:27:33 +00003070
Sebastian Redl10f04a62011-12-22 14:44:04 +00003071 // - Otherwise, if T is a class type, constructors are considered. The
3072 // applicable constructors are enumerated, and the best one is chosen
3073 // through overload resolution.
David Blaikie3bc93e32012-12-19 00:45:41 +00003074 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003075 // The container holding the constructors can under certain conditions
3076 // be changed while iterating (e.g. because of deserialization).
3077 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003078 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Sebastian Redl10f04a62011-12-22 14:44:04 +00003079
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003080 OverloadingResult Result = OR_No_Viable_Function;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003081 OverloadCandidateSet::iterator Best;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003082 bool AsInitializerList = false;
3083
3084 // C++11 [over.match.list]p1:
3085 // When objects of non-aggregate type T are list-initialized, overload
3086 // resolution selects the constructor in two phases:
3087 // - Initially, the candidate functions are the initializer-list
3088 // constructors of the class T and the argument list consists of the
3089 // initializer list as a single argument.
3090 if (InitListSyntax) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003091 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003092 AsInitializerList = true;
Richard Smithf4bb8d02012-07-05 08:39:21 +00003093
3094 // If the initializer list has no elements and T has a default constructor,
3095 // the first phase is omitted.
Richard Smithe5411b72012-12-01 02:35:44 +00003096 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003097 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003098 CandidateSet, Ctors, Best,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003099 CopyInitialization, AllowExplicit,
3100 /*OnlyListConstructor=*/true,
3101 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003102
3103 // Time to unwrap the init list.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003104 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003105 }
3106
3107 // C++11 [over.match.list]p1:
3108 // - If no viable initializer-list constructor is found, overload resolution
3109 // is performed again, where the candidate functions are all the
Richard Smithf4bb8d02012-07-05 08:39:21 +00003110 // constructors of the class T and the argument list consists of the
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003111 // elements of the initializer list.
3112 if (Result == OR_No_Viable_Function) {
3113 AsInitializerList = false;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003114 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003115 CandidateSet, Ctors, Best,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003116 CopyInitialization, AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003117 /*OnlyListConstructors=*/false,
3118 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003119 }
3120 if (Result) {
Sebastian Redl08ae3692012-02-04 21:27:33 +00003121 Sequence.SetOverloadFailure(InitListSyntax ?
Sebastian Redlcf15cef2011-12-22 18:58:38 +00003122 InitializationSequence::FK_ListConstructorOverloadFailed :
3123 InitializationSequence::FK_ConstructorOverloadFailed,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003124 Result);
3125 return;
3126 }
3127
Richard Smithf4bb8d02012-07-05 08:39:21 +00003128 // C++11 [dcl.init]p6:
Sebastian Redl10f04a62011-12-22 14:44:04 +00003129 // If a program calls for the default initialization of an object
3130 // of a const-qualified type T, T shall be a class type with a
3131 // user-provided default constructor.
3132 if (Kind.getKind() == InitializationKind::IK_Default &&
3133 Entity.getType().isConstQualified() &&
Aaron Ballman51217812012-07-31 22:40:31 +00003134 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00003135 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3136 return;
3137 }
3138
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003139 // C++11 [over.match.list]p1:
3140 // In copy-list-initialization, if an explicit constructor is chosen, the
3141 // initializer is ill-formed.
3142 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3143 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3144 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3145 return;
3146 }
3147
Sebastian Redl10f04a62011-12-22 14:44:04 +00003148 // Add the constructor initialization step. Any cv-qualification conversion is
3149 // subsumed by the initialization.
3150 bool HadMultipleCandidates = (CandidateSet.size() > 1);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003151 Sequence.AddConstructorInitializationStep(CtorDecl,
3152 Best->FoundDecl.getAccess(),
3153 DestType, HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003154 InitListSyntax, AsInitializerList);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003155}
3156
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003157static bool
3158ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3159 Expr *Initializer,
3160 QualType &SourceType,
3161 QualType &UnqualifiedSourceType,
3162 QualType UnqualifiedTargetType,
3163 InitializationSequence &Sequence) {
3164 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3165 S.Context.OverloadTy) {
3166 DeclAccessPair Found;
3167 bool HadMultipleCandidates = false;
3168 if (FunctionDecl *Fn
3169 = S.ResolveAddressOfOverloadedFunction(Initializer,
3170 UnqualifiedTargetType,
3171 false, Found,
3172 &HadMultipleCandidates)) {
3173 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3174 HadMultipleCandidates);
3175 SourceType = Fn->getType();
3176 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3177 } else if (!UnqualifiedTargetType->isRecordType()) {
3178 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3179 return true;
3180 }
3181 }
3182 return false;
3183}
3184
3185static void TryReferenceInitializationCore(Sema &S,
3186 const InitializedEntity &Entity,
3187 const InitializationKind &Kind,
3188 Expr *Initializer,
3189 QualType cv1T1, QualType T1,
3190 Qualifiers T1Quals,
3191 QualType cv2T2, QualType T2,
3192 Qualifiers T2Quals,
3193 InitializationSequence &Sequence);
3194
Richard Smithf4bb8d02012-07-05 08:39:21 +00003195static void TryValueInitialization(Sema &S,
3196 const InitializedEntity &Entity,
3197 const InitializationKind &Kind,
3198 InitializationSequence &Sequence,
3199 InitListExpr *InitList = 0);
3200
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003201static void TryListInitialization(Sema &S,
3202 const InitializedEntity &Entity,
3203 const InitializationKind &Kind,
3204 InitListExpr *InitList,
3205 InitializationSequence &Sequence);
3206
3207/// \brief Attempt list initialization of a reference.
3208static void TryReferenceListInitialization(Sema &S,
3209 const InitializedEntity &Entity,
3210 const InitializationKind &Kind,
3211 InitListExpr *InitList,
Richard Smithb6e38082013-06-08 00:02:08 +00003212 InitializationSequence &Sequence) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003213 // First, catch C++03 where this isn't possible.
Richard Smith80ad52f2013-01-02 11:42:31 +00003214 if (!S.getLangOpts().CPlusPlus11) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003215 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3216 return;
3217 }
3218
3219 QualType DestType = Entity.getType();
3220 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3221 Qualifiers T1Quals;
3222 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3223
3224 // Reference initialization via an initializer list works thus:
3225 // If the initializer list consists of a single element that is
3226 // reference-related to the referenced type, bind directly to that element
3227 // (possibly creating temporaries).
3228 // Otherwise, initialize a temporary with the initializer list and
3229 // bind to that.
3230 if (InitList->getNumInits() == 1) {
3231 Expr *Initializer = InitList->getInit(0);
3232 QualType cv2T2 = Initializer->getType();
3233 Qualifiers T2Quals;
3234 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3235
3236 // If this fails, creating a temporary wouldn't work either.
3237 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3238 T1, Sequence))
3239 return;
3240
3241 SourceLocation DeclLoc = Initializer->getLocStart();
3242 bool dummy1, dummy2, dummy3;
3243 Sema::ReferenceCompareResult RefRelationship
3244 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3245 dummy2, dummy3);
3246 if (RefRelationship >= Sema::Ref_Related) {
3247 // Try to bind the reference here.
3248 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3249 T1Quals, cv2T2, T2, T2Quals, Sequence);
3250 if (Sequence)
3251 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3252 return;
3253 }
Richard Smith02d65ee2013-01-15 07:58:29 +00003254
3255 // Update the initializer if we've resolved an overloaded function.
3256 if (Sequence.step_begin() != Sequence.step_end())
3257 Sequence.RewrapReferenceInitList(cv1T1, InitList);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003258 }
3259
3260 // Not reference-related. Create a temporary and bind to that.
3261 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3262
3263 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3264 if (Sequence) {
3265 if (DestType->isRValueReferenceType() ||
3266 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3267 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3268 else
3269 Sequence.SetFailed(
3270 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3271 }
3272}
3273
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003274/// \brief Attempt list initialization (C++0x [dcl.init.list])
3275static void TryListInitialization(Sema &S,
3276 const InitializedEntity &Entity,
3277 const InitializationKind &Kind,
3278 InitListExpr *InitList,
3279 InitializationSequence &Sequence) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003280 QualType DestType = Entity.getType();
3281
Sebastian Redl14b0c192011-09-24 17:48:00 +00003282 // C++ doesn't allow scalar initialization with more than one argument.
3283 // But C99 complex numbers are scalars and it makes sense there.
David Blaikie4e4d0842012-03-11 07:00:24 +00003284 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
Sebastian Redl14b0c192011-09-24 17:48:00 +00003285 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3286 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3287 return;
3288 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00003289 if (DestType->isReferenceType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003290 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003291 return;
Sebastian Redl14b0c192011-09-24 17:48:00 +00003292 }
Sebastian Redld2231c92012-02-19 12:27:43 +00003293 if (DestType->isRecordType()) {
Douglas Gregord10099e2012-05-04 16:32:21 +00003294 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003295 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redld2231c92012-02-19 12:27:43 +00003296 return;
3297 }
3298
Richard Smithf4bb8d02012-07-05 08:39:21 +00003299 // C++11 [dcl.init.list]p3:
3300 // - If T is an aggregate, aggregate initialization is performed.
Sebastian Redld2231c92012-02-19 12:27:43 +00003301 if (!DestType->isAggregateType()) {
Richard Smith80ad52f2013-01-02 11:42:31 +00003302 if (S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003303 // - Otherwise, if the initializer list has no elements and T is a
3304 // class type with a default constructor, the object is
3305 // value-initialized.
3306 if (InitList->getNumInits() == 0) {
3307 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
Richard Smithe5411b72012-12-01 02:35:44 +00003308 if (RD->hasDefaultConstructor()) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003309 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3310 return;
3311 }
3312 }
3313
3314 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3315 // an initializer_list object constructed [...]
3316 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3317 return;
3318
3319 // - Otherwise, if T is a class type, constructors are considered.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003320 Expr *InitListAsExpr = InitList;
3321 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003322 Sequence, /*InitListSyntax*/true);
Sebastian Redld2231c92012-02-19 12:27:43 +00003323 } else
3324 Sequence.SetFailed(
3325 InitializationSequence::FK_InitListBadDestinationType);
3326 return;
3327 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003328 }
3329
Sebastian Redl14b0c192011-09-24 17:48:00 +00003330 InitListChecker CheckInitList(S, Entity, InitList,
Richard Smith40cba902013-06-06 11:41:05 +00003331 DestType, /*VerifyOnly=*/true);
Sebastian Redl14b0c192011-09-24 17:48:00 +00003332 if (CheckInitList.HadError()) {
3333 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3334 return;
3335 }
3336
3337 // Add the list initialization step with the built init list.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003338 Sequence.AddListInitializationStep(DestType);
3339}
Douglas Gregor20093b42009-12-09 23:02:17 +00003340
3341/// \brief Try a reference initialization that involves calling a conversion
3342/// function.
Douglas Gregor20093b42009-12-09 23:02:17 +00003343static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3344 const InitializedEntity &Entity,
3345 const InitializationKind &Kind,
Douglas Gregored878af2012-02-24 23:56:31 +00003346 Expr *Initializer,
3347 bool AllowRValues,
Douglas Gregor20093b42009-12-09 23:02:17 +00003348 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003349 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003350 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3351 QualType T1 = cv1T1.getUnqualifiedType();
3352 QualType cv2T2 = Initializer->getType();
3353 QualType T2 = cv2T2.getUnqualifiedType();
3354
3355 bool DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003356 bool ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003357 bool ObjCLifetimeConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003358 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
Douglas Gregor569c3162010-08-07 11:51:51 +00003359 T1, T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003360 ObjCConversion,
3361 ObjCLifetimeConversion) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003362 "Must have incompatible references when binding via conversion");
Chandler Carruth60cfcec2009-12-13 01:37:04 +00003363 (void)DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003364 (void)ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003365 (void)ObjCLifetimeConversion;
3366
Douglas Gregor20093b42009-12-09 23:02:17 +00003367 // Build the candidate set directly in the initialization sequence
3368 // structure, so that it will persist if we fail.
3369 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3370 CandidateSet.clear();
3371
3372 // Determine whether we are allowed to call explicit constructors or
3373 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003374 bool AllowExplicit = Kind.AllowExplicit();
Douglas Gregored878af2012-02-24 23:56:31 +00003375 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctions();
3376
Douglas Gregor20093b42009-12-09 23:02:17 +00003377 const RecordType *T1RecordType = 0;
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003378 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3379 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003380 // The type we're converting to is a class type. Enumerate its constructors
3381 // to see if there is a suitable conversion.
3382 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
John McCall572fc622010-08-17 07:23:57 +00003383
David Blaikie3bc93e32012-12-19 00:45:41 +00003384 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003385 // The container holding the constructors can under certain conditions
3386 // be changed while iterating (e.g. because of deserialization).
3387 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003388 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003389 for (SmallVector<NamedDecl*, 16>::iterator
3390 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3391 NamedDecl *D = *CI;
John McCall9aa472c2010-03-19 07:35:19 +00003392 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3393
Douglas Gregor20093b42009-12-09 23:02:17 +00003394 // Find the constructor (which may be a template).
3395 CXXConstructorDecl *Constructor = 0;
John McCall9aa472c2010-03-19 07:35:19 +00003396 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor20093b42009-12-09 23:02:17 +00003397 if (ConstructorTmpl)
3398 Constructor = cast<CXXConstructorDecl>(
3399 ConstructorTmpl->getTemplatedDecl());
3400 else
John McCall9aa472c2010-03-19 07:35:19 +00003401 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003402
Douglas Gregor20093b42009-12-09 23:02:17 +00003403 if (!Constructor->isInvalidDecl() &&
3404 Constructor->isConvertingConstructor(AllowExplicit)) {
3405 if (ConstructorTmpl)
John McCall9aa472c2010-03-19 07:35:19 +00003406 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
John McCall86820f52010-01-26 01:37:31 +00003407 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003408 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003409 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003410 else
John McCall9aa472c2010-03-19 07:35:19 +00003411 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003412 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003413 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003414 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003415 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003416 }
John McCall572fc622010-08-17 07:23:57 +00003417 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3418 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003419
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003420 const RecordType *T2RecordType = 0;
3421 if ((T2RecordType = T2->getAs<RecordType>()) &&
3422 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003423 // The type we're converting from is a class type, enumerate its conversion
3424 // functions.
3425 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3426
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00003427 std::pair<CXXRecordDecl::conversion_iterator,
3428 CXXRecordDecl::conversion_iterator>
3429 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3430 for (CXXRecordDecl::conversion_iterator
3431 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003432 NamedDecl *D = *I;
3433 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3434 if (isa<UsingShadowDecl>(D))
3435 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003436
Douglas Gregor20093b42009-12-09 23:02:17 +00003437 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3438 CXXConversionDecl *Conv;
3439 if (ConvTemplate)
3440 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3441 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003442 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003443
Douglas Gregor20093b42009-12-09 23:02:17 +00003444 // If the conversion function doesn't return a reference type,
3445 // it can't be considered for this conversion unless we're allowed to
3446 // consider rvalues.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003447 // FIXME: Do we need to make sure that we only consider conversion
3448 // candidates with reference-compatible results? That might be needed to
Douglas Gregor20093b42009-12-09 23:02:17 +00003449 // break recursion.
Douglas Gregored878af2012-02-24 23:56:31 +00003450 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003451 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3452 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00003453 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00003454 ActingDC, Initializer,
Douglas Gregor564cb062011-01-21 00:27:08 +00003455 DestType, CandidateSet);
Douglas Gregor20093b42009-12-09 23:02:17 +00003456 else
John McCall9aa472c2010-03-19 07:35:19 +00003457 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Douglas Gregor564cb062011-01-21 00:27:08 +00003458 Initializer, DestType, CandidateSet);
Douglas Gregor20093b42009-12-09 23:02:17 +00003459 }
3460 }
3461 }
John McCall572fc622010-08-17 07:23:57 +00003462 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3463 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003464
Douglas Gregor20093b42009-12-09 23:02:17 +00003465 SourceLocation DeclLoc = Initializer->getLocStart();
3466
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003467 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor20093b42009-12-09 23:02:17 +00003468 OverloadCandidateSet::iterator Best;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003469 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00003470 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
Douglas Gregor20093b42009-12-09 23:02:17 +00003471 return Result;
Eli Friedman03981012009-12-11 02:42:07 +00003472
Douglas Gregor20093b42009-12-09 23:02:17 +00003473 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00003474 // This is the overload that will be used for this initialization step if we
3475 // use this initialization. Mark it as referenced.
3476 Function->setReferenced();
Chandler Carruth25ca4212011-02-25 19:41:05 +00003477
Eli Friedman03981012009-12-11 02:42:07 +00003478 // Compute the returned type of the conversion.
Douglas Gregor20093b42009-12-09 23:02:17 +00003479 if (isa<CXXConversionDecl>(Function))
3480 T2 = Function->getResultType();
3481 else
3482 T2 = cv1T1;
Eli Friedman03981012009-12-11 02:42:07 +00003483
3484 // Add the user-defined conversion step.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003485 bool HadMultipleCandidates = (CandidateSet.size() > 1);
John McCall9aa472c2010-03-19 07:35:19 +00003486 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003487 T2.getNonLValueExprType(S.Context),
3488 HadMultipleCandidates);
Eli Friedman03981012009-12-11 02:42:07 +00003489
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003490 // Determine whether we need to perform derived-to-base or
Eli Friedman03981012009-12-11 02:42:07 +00003491 // cv-qualification adjustments.
John McCall5baba9d2010-08-25 10:28:54 +00003492 ExprValueKind VK = VK_RValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003493 if (T2->isLValueReferenceType())
John McCall5baba9d2010-08-25 10:28:54 +00003494 VK = VK_LValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003495 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
John McCall5baba9d2010-08-25 10:28:54 +00003496 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003497
Douglas Gregor20093b42009-12-09 23:02:17 +00003498 bool NewDerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003499 bool NewObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003500 bool NewObjCLifetimeConversion = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00003501 Sema::ReferenceCompareResult NewRefRelationship
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003502 = S.CompareReferenceRelationship(DeclLoc, T1,
Douglas Gregor63982352010-07-13 18:40:04 +00003503 T2.getNonLValueExprType(S.Context),
John McCallf85e1932011-06-15 23:02:42 +00003504 NewDerivedToBase, NewObjCConversion,
3505 NewObjCLifetimeConversion);
Douglas Gregora1a9f032010-03-07 23:17:44 +00003506 if (NewRefRelationship == Sema::Ref_Incompatible) {
3507 // If the type we've converted to is not reference-related to the
3508 // type we're looking for, then there is another conversion step
3509 // we need to perform to produce a temporary of the right type
3510 // that we'll be binding to.
3511 ImplicitConversionSequence ICS;
3512 ICS.setStandard();
3513 ICS.Standard = Best->FinalConversion;
3514 T2 = ICS.Standard.getToType(2);
3515 Sequence.AddConversionSequenceStep(ICS, T2);
3516 } else if (NewDerivedToBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00003517 Sequence.AddDerivedToBaseCastStep(
3518 S.Context.getQualifiedType(T1,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003519 T2.getNonReferenceType().getQualifiers()),
John McCall5baba9d2010-08-25 10:28:54 +00003520 VK);
Douglas Gregor569c3162010-08-07 11:51:51 +00003521 else if (NewObjCConversion)
3522 Sequence.AddObjCObjectConversionStep(
3523 S.Context.getQualifiedType(T1,
3524 T2.getNonReferenceType().getQualifiers()));
3525
Douglas Gregor20093b42009-12-09 23:02:17 +00003526 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
John McCall5baba9d2010-08-25 10:28:54 +00003527 Sequence.AddQualificationConversionStep(cv1T1, VK);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003528
Douglas Gregor20093b42009-12-09 23:02:17 +00003529 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3530 return OR_Success;
3531}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003532
Richard Smith83da2e72011-10-19 16:55:56 +00003533static void CheckCXX98CompatAccessibleCopy(Sema &S,
3534 const InitializedEntity &Entity,
3535 Expr *CurInitExpr);
3536
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003537/// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3538static void TryReferenceInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003539 const InitializedEntity &Entity,
3540 const InitializationKind &Kind,
3541 Expr *Initializer,
3542 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003543 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003544 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003545 Qualifiers T1Quals;
3546 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
Douglas Gregor20093b42009-12-09 23:02:17 +00003547 QualType cv2T2 = Initializer->getType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003548 Qualifiers T2Quals;
3549 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003550
Douglas Gregor20093b42009-12-09 23:02:17 +00003551 // If the initializer is the address of an overloaded function, try
3552 // to resolve the overloaded function. If all goes well, T2 is the
3553 // type of the resulting function.
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003554 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3555 T1, Sequence))
3556 return;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003557
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003558 // Delegate everything else to a subfunction.
3559 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3560 T1Quals, cv2T2, T2, T2Quals, Sequence);
3561}
3562
Jordan Rose1fd1e282013-04-11 00:58:58 +00003563/// Converts the target of reference initialization so that it has the
3564/// appropriate qualifiers and value kind.
3565///
3566/// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
3567/// \code
3568/// int x;
3569/// const int &r = x;
3570/// \endcode
3571///
3572/// In this case the reference is binding to a bitfield lvalue, which isn't
3573/// valid. Perform a load to create a lifetime-extended temporary instead.
3574/// \code
3575/// const int &r = someStruct.bitfield;
3576/// \endcode
3577static ExprValueKind
3578convertQualifiersAndValueKindIfNecessary(Sema &S,
3579 InitializationSequence &Sequence,
3580 Expr *Initializer,
3581 QualType cv1T1,
3582 Qualifiers T1Quals,
3583 Qualifiers T2Quals,
3584 bool IsLValueRef) {
John McCall993f43f2013-05-06 21:39:12 +00003585 bool IsNonAddressableType = Initializer->refersToBitField() ||
Jordan Rose1fd1e282013-04-11 00:58:58 +00003586 Initializer->refersToVectorElement();
3587
3588 if (IsNonAddressableType) {
3589 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
3590 // lvalue reference to a non-volatile const type, or the reference shall be
3591 // an rvalue reference.
3592 //
3593 // If not, we can't make a temporary and bind to that. Give up and allow the
3594 // error to be diagnosed later.
3595 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
3596 assert(Initializer->isGLValue());
3597 return Initializer->getValueKind();
3598 }
3599
3600 // Force a load so we can materialize a temporary.
3601 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
3602 return VK_RValue;
3603 }
3604
3605 if (T1Quals != T2Quals) {
3606 Sequence.AddQualificationConversionStep(cv1T1,
3607 Initializer->getValueKind());
3608 }
3609
3610 return Initializer->getValueKind();
3611}
3612
3613
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003614/// \brief Reference initialization without resolving overloaded functions.
3615static void TryReferenceInitializationCore(Sema &S,
3616 const InitializedEntity &Entity,
3617 const InitializationKind &Kind,
3618 Expr *Initializer,
3619 QualType cv1T1, QualType T1,
3620 Qualifiers T1Quals,
3621 QualType cv2T2, QualType T2,
3622 Qualifiers T2Quals,
3623 InitializationSequence &Sequence) {
3624 QualType DestType = Entity.getType();
3625 SourceLocation DeclLoc = Initializer->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00003626 // Compute some basic properties of the types and the initializer.
3627 bool isLValueRef = DestType->isLValueReferenceType();
3628 bool isRValueRef = !isLValueRef;
3629 bool DerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003630 bool ObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003631 bool ObjCLifetimeConversion = false;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003632 Expr::Classification InitCategory = Initializer->Classify(S.Context);
Douglas Gregor20093b42009-12-09 23:02:17 +00003633 Sema::ReferenceCompareResult RefRelationship
Douglas Gregor569c3162010-08-07 11:51:51 +00003634 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003635 ObjCConversion, ObjCLifetimeConversion);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003636
Douglas Gregor20093b42009-12-09 23:02:17 +00003637 // C++0x [dcl.init.ref]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003638 // A reference to type "cv1 T1" is initialized by an expression of type
Douglas Gregor20093b42009-12-09 23:02:17 +00003639 // "cv2 T2" as follows:
3640 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003641 // - If the reference is an lvalue reference and the initializer
Douglas Gregor20093b42009-12-09 23:02:17 +00003642 // expression
Sebastian Redl4680bf22010-06-30 18:13:39 +00003643 // Note the analogous bullet points for rvlaue refs to functions. Because
3644 // there are no function rvalues in C++, rvalue refs to functions are treated
3645 // like lvalue refs.
Douglas Gregor20093b42009-12-09 23:02:17 +00003646 OverloadingResult ConvOvlResult = OR_Success;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003647 bool T1Function = T1->isFunctionType();
3648 if (isLValueRef || T1Function) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003649 if (InitCategory.isLValue() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003650 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003651 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003652 RefRelationship == Sema::Ref_Related))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003653 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
Douglas Gregor20093b42009-12-09 23:02:17 +00003654 // reference-compatible with "cv2 T2," or
3655 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003656 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
Douglas Gregor20093b42009-12-09 23:02:17 +00003657 // bit-field when we're determining whether the reference initialization
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003658 // can occur. However, we do pay attention to whether it is a bit-field
3659 // to decide whether we're actually binding to a temporary created from
3660 // the bit-field.
Douglas Gregor20093b42009-12-09 23:02:17 +00003661 if (DerivedToBase)
3662 Sequence.AddDerivedToBaseCastStep(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003663 S.Context.getQualifiedType(T1, T2Quals),
John McCall5baba9d2010-08-25 10:28:54 +00003664 VK_LValue);
Douglas Gregor569c3162010-08-07 11:51:51 +00003665 else if (ObjCConversion)
3666 Sequence.AddObjCObjectConversionStep(
3667 S.Context.getQualifiedType(T1, T2Quals));
3668
Jordan Rose1fd1e282013-04-11 00:58:58 +00003669 ExprValueKind ValueKind =
3670 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
3671 cv1T1, T1Quals, T2Quals,
3672 isLValueRef);
3673 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
Douglas Gregor20093b42009-12-09 23:02:17 +00003674 return;
3675 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003676
3677 // - has a class type (i.e., T2 is a class type), where T1 is not
3678 // reference-related to T2, and can be implicitly converted to an
3679 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3680 // with "cv3 T3" (this conversion is selected by enumerating the
Douglas Gregor20093b42009-12-09 23:02:17 +00003681 // applicable conversion functions (13.3.1.6) and choosing the best
3682 // one through overload resolution (13.3)),
Sebastian Redl4680bf22010-06-30 18:13:39 +00003683 // If we have an rvalue ref to function type here, the rhs must be
3684 // an rvalue.
3685 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3686 (isLValueRef || InitCategory.isRValue())) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003687 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind,
Douglas Gregor20093b42009-12-09 23:02:17 +00003688 Initializer,
Sebastian Redl4680bf22010-06-30 18:13:39 +00003689 /*AllowRValues=*/isRValueRef,
Douglas Gregor20093b42009-12-09 23:02:17 +00003690 Sequence);
3691 if (ConvOvlResult == OR_Success)
3692 return;
John McCall1d318332010-01-12 00:44:57 +00003693 if (ConvOvlResult != OR_No_Viable_Function) {
3694 Sequence.SetOverloadFailure(
3695 InitializationSequence::FK_ReferenceInitOverloadFailed,
3696 ConvOvlResult);
3697 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003698 }
3699 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003700
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003701 // - Otherwise, the reference shall be an lvalue reference to a
Douglas Gregor20093b42009-12-09 23:02:17 +00003702 // non-volatile const type (i.e., cv1 shall be const), or the reference
Douglas Gregor69d83162011-01-20 16:08:06 +00003703 // shall be an rvalue reference.
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003704 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
Douglas Gregor3afb9772010-11-08 15:20:28 +00003705 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3706 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3707 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
Douglas Gregor20093b42009-12-09 23:02:17 +00003708 Sequence.SetOverloadFailure(
3709 InitializationSequence::FK_ReferenceInitOverloadFailed,
3710 ConvOvlResult);
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003711 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003712 Sequence.SetFailed(InitCategory.isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00003713 ? (RefRelationship == Sema::Ref_Related
3714 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3715 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3716 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003717
Douglas Gregor20093b42009-12-09 23:02:17 +00003718 return;
3719 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003720
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003721 // - If the initializer expression
3722 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3723 // "cv1 T1" is reference-compatible with "cv2 T2"
3724 // Note: functions are handled below.
3725 if (!T1Function &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003726 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003727 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003728 RefRelationship == Sema::Ref_Related)) &&
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003729 (InitCategory.isXValue() ||
3730 (InitCategory.isPRValue() && T2->isRecordType()) ||
3731 (InitCategory.isPRValue() && T2->isArrayType()))) {
3732 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3733 if (InitCategory.isPRValue() && T2->isRecordType()) {
Douglas Gregor523d46a2010-04-18 07:40:54 +00003734 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3735 // compiler the freedom to perform a copy here or bind to the
3736 // object, while C++0x requires that we bind directly to the
3737 // object. Hence, we always bind to the object without making an
3738 // extra copy. However, in C++03 requires that we check for the
3739 // presence of a suitable copy constructor:
3740 //
3741 // The constructor that would be used to make the copy shall
3742 // be callable whether or not the copy is actually done.
Richard Smith80ad52f2013-01-02 11:42:31 +00003743 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
Douglas Gregor523d46a2010-04-18 07:40:54 +00003744 Sequence.AddExtraneousCopyToTemporary(cv2T2);
Richard Smith80ad52f2013-01-02 11:42:31 +00003745 else if (S.getLangOpts().CPlusPlus11)
Richard Smith83da2e72011-10-19 16:55:56 +00003746 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
Douglas Gregor20093b42009-12-09 23:02:17 +00003747 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003748
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003749 if (DerivedToBase)
3750 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3751 ValueKind);
3752 else if (ObjCConversion)
3753 Sequence.AddObjCObjectConversionStep(
3754 S.Context.getQualifiedType(T1, T2Quals));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003755
Jordan Rose1fd1e282013-04-11 00:58:58 +00003756 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
3757 Initializer, cv1T1,
3758 T1Quals, T2Quals,
3759 isLValueRef);
3760
3761 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003762 return;
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003763 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003764
3765 // - has a class type (i.e., T2 is a class type), where T1 is not
3766 // reference-related to T2, and can be implicitly converted to an
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003767 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3768 // where "cv1 T1" is reference-compatible with "cv3 T3",
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003769 if (T2->isRecordType()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003770 if (RefRelationship == Sema::Ref_Incompatible) {
3771 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity,
3772 Kind, Initializer,
3773 /*AllowRValues=*/true,
3774 Sequence);
3775 if (ConvOvlResult)
3776 Sequence.SetOverloadFailure(
3777 InitializationSequence::FK_ReferenceInitOverloadFailed,
3778 ConvOvlResult);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003779
Douglas Gregor20093b42009-12-09 23:02:17 +00003780 return;
3781 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003782
Douglas Gregordefa32e2013-03-26 23:59:23 +00003783 if ((RefRelationship == Sema::Ref_Compatible ||
3784 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
3785 isRValueRef && InitCategory.isLValue()) {
3786 Sequence.SetFailed(
3787 InitializationSequence::FK_RValueReferenceBindingToLValue);
3788 return;
3789 }
3790
Douglas Gregor20093b42009-12-09 23:02:17 +00003791 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3792 return;
3793 }
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003794
3795 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
Douglas Gregor20093b42009-12-09 23:02:17 +00003796 // from the initializer expression using the rules for a non-reference
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003797 // copy initialization (8.5). The reference is then bound to the
Douglas Gregor20093b42009-12-09 23:02:17 +00003798 // temporary. [...]
John McCall369371c2010-06-04 02:29:22 +00003799
Douglas Gregor20093b42009-12-09 23:02:17 +00003800 // Determine whether we are allowed to call explicit constructors or
3801 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003802 bool AllowExplicit = Kind.AllowExplicit();
John McCall369371c2010-06-04 02:29:22 +00003803
3804 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3805
John McCallf85e1932011-06-15 23:02:42 +00003806 ImplicitConversionSequence ICS
3807 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
John McCall369371c2010-06-04 02:29:22 +00003808 /*SuppressUserConversions*/ false,
3809 AllowExplicit,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003810 /*FIXME:InOverloadResolution=*/false,
John McCallf85e1932011-06-15 23:02:42 +00003811 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3812 /*AllowObjCWritebackConversion=*/false);
3813
3814 if (ICS.isBad()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003815 // FIXME: Use the conversion function set stored in ICS to turn
3816 // this into an overloading ambiguity diagnostic. However, we need
3817 // to keep that set as an OverloadCandidateSet rather than as some
3818 // other kind of set.
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003819 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3820 Sequence.SetOverloadFailure(
3821 InitializationSequence::FK_ReferenceInitOverloadFailed,
3822 ConvOvlResult);
Douglas Gregor3afb9772010-11-08 15:20:28 +00003823 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3824 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003825 else
3826 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
Douglas Gregor20093b42009-12-09 23:02:17 +00003827 return;
John McCallf85e1932011-06-15 23:02:42 +00003828 } else {
3829 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003830 }
3831
3832 // [...] If T1 is reference-related to T2, cv1 must be the
3833 // same cv-qualification as, or greater cv-qualification
3834 // than, cv2; otherwise, the program is ill-formed.
Chandler Carruth5535c382010-01-12 20:32:25 +00003835 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3836 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003837 if (RefRelationship == Sema::Ref_Related &&
Chandler Carruth5535c382010-01-12 20:32:25 +00003838 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003839 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3840 return;
3841 }
3842
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003843 // [...] If T1 is reference-related to T2 and the reference is an rvalue
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003844 // reference, the initializer expression shall not be an lvalue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003845 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003846 InitCategory.isLValue()) {
3847 Sequence.SetFailed(
3848 InitializationSequence::FK_RValueReferenceBindingToLValue);
3849 return;
3850 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003851
Douglas Gregor20093b42009-12-09 23:02:17 +00003852 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3853 return;
3854}
3855
3856/// \brief Attempt character array initialization from a string literal
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003857/// (C++ [dcl.init.string], C99 6.7.8).
3858static void TryStringLiteralInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003859 const InitializedEntity &Entity,
3860 const InitializationKind &Kind,
3861 Expr *Initializer,
3862 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003863 Sequence.AddStringInitStep(Entity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003864}
3865
Douglas Gregor71d17402009-12-15 00:01:57 +00003866/// \brief Attempt value initialization (C++ [dcl.init]p7).
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003867static void TryValueInitialization(Sema &S,
Douglas Gregor71d17402009-12-15 00:01:57 +00003868 const InitializedEntity &Entity,
3869 const InitializationKind &Kind,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003870 InitializationSequence &Sequence,
3871 InitListExpr *InitList) {
3872 assert((!InitList || InitList->getNumInits() == 0) &&
3873 "Shouldn't use value-init for non-empty init lists");
3874
Richard Smith1d0c9a82012-02-14 21:14:13 +00003875 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
Douglas Gregor71d17402009-12-15 00:01:57 +00003876 //
3877 // To value-initialize an object of type T means:
Douglas Gregord6542d82009-12-22 15:35:07 +00003878 QualType T = Entity.getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003879
Douglas Gregor71d17402009-12-15 00:01:57 +00003880 // -- if T is an array type, then each element is value-initialized;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003881 T = S.Context.getBaseElementType(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003882
Douglas Gregor71d17402009-12-15 00:01:57 +00003883 if (const RecordType *RT = T->getAs<RecordType>()) {
3884 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003885 bool NeedZeroInitialization = true;
Richard Smith80ad52f2013-01-02 11:42:31 +00003886 if (!S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003887 // C++98:
3888 // -- if T is a class type (clause 9) with a user-declared constructor
3889 // (12.1), then the default constructor for T is called (and the
3890 // initialization is ill-formed if T has no accessible default
3891 // constructor);
Richard Smith1d0c9a82012-02-14 21:14:13 +00003892 if (ClassDecl->hasUserDeclaredConstructor())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003893 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003894 } else {
3895 // C++11:
3896 // -- if T is a class type (clause 9) with either no default constructor
3897 // (12.1 [class.ctor]) or a default constructor that is user-provided
3898 // or deleted, then the object is default-initialized;
3899 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
3900 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003901 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003902 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003903
Richard Smith1d0c9a82012-02-14 21:14:13 +00003904 // -- if T is a (possibly cv-qualified) non-union class type without a
3905 // user-provided or deleted default constructor, then the object is
3906 // zero-initialized and, if T has a non-trivial default constructor,
3907 // default-initialized;
Richard Smith6678a052012-10-18 00:44:17 +00003908 // The 'non-union' here was removed by DR1502. The 'non-trivial default
3909 // constructor' part was removed by DR1507.
Richard Smithf4bb8d02012-07-05 08:39:21 +00003910 if (NeedZeroInitialization)
3911 Sequence.AddZeroInitializationStep(Entity.getType());
3912
Richard Smithd5bc8672012-12-08 02:01:17 +00003913 // C++03:
3914 // -- if T is a non-union class type without a user-declared constructor,
3915 // then every non-static data member and base class component of T is
3916 // value-initialized;
3917 // [...] A program that calls for [...] value-initialization of an
3918 // entity of reference type is ill-formed.
3919 //
3920 // C++11 doesn't need this handling, because value-initialization does not
3921 // occur recursively there, and the implicit default constructor is
3922 // defined as deleted in the problematic cases.
Richard Smith80ad52f2013-01-02 11:42:31 +00003923 if (!S.getLangOpts().CPlusPlus11 &&
Richard Smithd5bc8672012-12-08 02:01:17 +00003924 ClassDecl->hasUninitializedReferenceMember()) {
3925 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
3926 return;
3927 }
3928
Richard Smithf4bb8d02012-07-05 08:39:21 +00003929 // If this is list-value-initialization, pass the empty init list on when
3930 // building the constructor call. This affects the semantics of a few
3931 // things (such as whether an explicit default constructor can be called).
3932 Expr *InitListAsExpr = InitList;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003933 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003934 bool InitListSyntax = InitList;
3935
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003936 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
3937 InitListSyntax);
Douglas Gregor71d17402009-12-15 00:01:57 +00003938 }
3939 }
3940
Douglas Gregord6542d82009-12-22 15:35:07 +00003941 Sequence.AddZeroInitializationStep(Entity.getType());
Douglas Gregor71d17402009-12-15 00:01:57 +00003942}
3943
Douglas Gregor99a2e602009-12-16 01:38:02 +00003944/// \brief Attempt default initialization (C++ [dcl.init]p6).
3945static void TryDefaultInitialization(Sema &S,
3946 const InitializedEntity &Entity,
3947 const InitializationKind &Kind,
3948 InitializationSequence &Sequence) {
3949 assert(Kind.getKind() == InitializationKind::IK_Default);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003950
Douglas Gregor99a2e602009-12-16 01:38:02 +00003951 // C++ [dcl.init]p6:
3952 // To default-initialize an object of type T means:
3953 // - if T is an array type, each element is default-initialized;
John McCallf85e1932011-06-15 23:02:42 +00003954 QualType DestType = S.Context.getBaseElementType(Entity.getType());
3955
Douglas Gregor99a2e602009-12-16 01:38:02 +00003956 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
3957 // constructor for T is called (and the initialization is ill-formed if
3958 // T has no accessible default constructor);
David Blaikie4e4d0842012-03-11 07:00:24 +00003959 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00003960 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
Chandler Carruth4e6fbce2010-08-23 07:55:51 +00003961 return;
Douglas Gregor99a2e602009-12-16 01:38:02 +00003962 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003963
Douglas Gregor99a2e602009-12-16 01:38:02 +00003964 // - otherwise, no initialization is performed.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003965
Douglas Gregor99a2e602009-12-16 01:38:02 +00003966 // If a program calls for the default initialization of an object of
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003967 // a const-qualified type T, T shall be a class type with a user-provided
Douglas Gregor99a2e602009-12-16 01:38:02 +00003968 // default constructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00003969 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
Douglas Gregor99a2e602009-12-16 01:38:02 +00003970 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
John McCallf85e1932011-06-15 23:02:42 +00003971 return;
3972 }
3973
3974 // If the destination type has a lifetime property, zero-initialize it.
3975 if (DestType.getQualifiers().hasObjCLifetime()) {
3976 Sequence.AddZeroInitializationStep(Entity.getType());
3977 return;
3978 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00003979}
3980
Douglas Gregor20093b42009-12-09 23:02:17 +00003981/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
3982/// which enumerates all conversion functions and performs overload resolution
3983/// to select the best.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003984static void TryUserDefinedConversion(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003985 const InitializedEntity &Entity,
3986 const InitializationKind &Kind,
3987 Expr *Initializer,
3988 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003989 QualType DestType = Entity.getType();
Douglas Gregor4a520a22009-12-14 17:27:33 +00003990 assert(!DestType->isReferenceType() && "References are handled elsewhere");
3991 QualType SourceType = Initializer->getType();
3992 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
3993 "Must have a class type to perform a user-defined conversion");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003994
Douglas Gregor4a520a22009-12-14 17:27:33 +00003995 // Build the candidate set directly in the initialization sequence
3996 // structure, so that it will persist if we fail.
3997 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3998 CandidateSet.clear();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003999
Douglas Gregor4a520a22009-12-14 17:27:33 +00004000 // Determine whether we are allowed to call explicit constructors or
4001 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00004002 bool AllowExplicit = Kind.AllowExplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004003
Douglas Gregor4a520a22009-12-14 17:27:33 +00004004 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4005 // The type we're converting to is a class type. Enumerate its constructors
4006 // to see if there is a suitable conversion.
4007 CXXRecordDecl *DestRecordDecl
4008 = cast<CXXRecordDecl>(DestRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004009
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004010 // Try to complete the type we're converting to.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004011 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004012 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004013 // The container holding the constructors can under certain conditions
4014 // be changed while iterating. To be safe we copy the lookup results
4015 // to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004016 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004017 for (SmallVector<NamedDecl*, 8>::iterator
4018 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004019 Con != ConEnd; ++Con) {
4020 NamedDecl *D = *Con;
4021 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004022
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004023 // Find the constructor (which may be a template).
4024 CXXConstructorDecl *Constructor = 0;
4025 FunctionTemplateDecl *ConstructorTmpl
4026 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004027 if (ConstructorTmpl)
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004028 Constructor = cast<CXXConstructorDecl>(
4029 ConstructorTmpl->getTemplatedDecl());
Douglas Gregor4712c022010-07-01 03:43:00 +00004030 else
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004031 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004032
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004033 if (!Constructor->isInvalidDecl() &&
4034 Constructor->isConvertingConstructor(AllowExplicit)) {
4035 if (ConstructorTmpl)
4036 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4037 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004038 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004039 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004040 else
4041 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004042 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004043 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004044 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004045 }
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004046 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004047 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004048
4049 SourceLocation DeclLoc = Initializer->getLocStart();
4050
Douglas Gregor4a520a22009-12-14 17:27:33 +00004051 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4052 // The type we're converting from is a class type, enumerate its conversion
4053 // functions.
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004054
Eli Friedman33c2da92009-12-20 22:12:03 +00004055 // We can only enumerate the conversion functions for a complete type; if
4056 // the type isn't complete, simply skip this step.
4057 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4058 CXXRecordDecl *SourceRecordDecl
4059 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004060
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00004061 std::pair<CXXRecordDecl::conversion_iterator,
4062 CXXRecordDecl::conversion_iterator>
4063 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
4064 for (CXXRecordDecl::conversion_iterator
4065 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Eli Friedman33c2da92009-12-20 22:12:03 +00004066 NamedDecl *D = *I;
4067 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4068 if (isa<UsingShadowDecl>(D))
4069 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004070
Eli Friedman33c2da92009-12-20 22:12:03 +00004071 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4072 CXXConversionDecl *Conv;
Douglas Gregor4a520a22009-12-14 17:27:33 +00004073 if (ConvTemplate)
Eli Friedman33c2da92009-12-20 22:12:03 +00004074 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
Douglas Gregor4a520a22009-12-14 17:27:33 +00004075 else
John McCall32daa422010-03-31 01:36:47 +00004076 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004077
Eli Friedman33c2da92009-12-20 22:12:03 +00004078 if (AllowExplicit || !Conv->isExplicit()) {
4079 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00004080 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00004081 ActingDC, Initializer, DestType,
Eli Friedman33c2da92009-12-20 22:12:03 +00004082 CandidateSet);
4083 else
John McCall9aa472c2010-03-19 07:35:19 +00004084 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
John McCall86820f52010-01-26 01:37:31 +00004085 Initializer, DestType, CandidateSet);
Eli Friedman33c2da92009-12-20 22:12:03 +00004086 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004087 }
4088 }
4089 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004090
4091 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004092 OverloadCandidateSet::iterator Best;
John McCall1d318332010-01-12 00:44:57 +00004093 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004094 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
Douglas Gregor4a520a22009-12-14 17:27:33 +00004095 Sequence.SetOverloadFailure(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004096 InitializationSequence::FK_UserConversionOverloadFailed,
Douglas Gregor4a520a22009-12-14 17:27:33 +00004097 Result);
4098 return;
4099 }
John McCall1d318332010-01-12 00:44:57 +00004100
Douglas Gregor4a520a22009-12-14 17:27:33 +00004101 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00004102 Function->setReferenced();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004103 bool HadMultipleCandidates = (CandidateSet.size() > 1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004104
Douglas Gregor4a520a22009-12-14 17:27:33 +00004105 if (isa<CXXConstructorDecl>(Function)) {
4106 // Add the user-defined conversion step. Any cv-qualification conversion is
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004107 // subsumed by the initialization. Per DR5, the created temporary is of the
4108 // cv-unqualified type of the destination.
4109 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4110 DestType.getUnqualifiedType(),
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004111 HadMultipleCandidates);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004112 return;
4113 }
4114
4115 // Add the user-defined conversion step that calls the conversion function.
Douglas Gregor5291c3c2010-07-13 08:18:22 +00004116 QualType ConvType = Function->getCallResultType();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004117 if (ConvType->getAs<RecordType>()) {
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004118 // If we're converting to a class type, there may be an copy of
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004119 // the resulting temporary object (possible to create an object of
4120 // a base class type). That copy is not a separate conversion, so
4121 // we just make a note of the actual destination type (possibly a
4122 // base class of the type returned by the conversion function) and
4123 // let the user-defined conversion step handle the conversion.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004124 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4125 HadMultipleCandidates);
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004126 return;
4127 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004128
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004129 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4130 HadMultipleCandidates);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004131
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004132 // If the conversion following the call to the conversion function
4133 // is interesting, add it as a separate step.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004134 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4135 Best->FinalConversion.Third) {
4136 ImplicitConversionSequence ICS;
John McCall1d318332010-01-12 00:44:57 +00004137 ICS.setStandard();
Douglas Gregor4a520a22009-12-14 17:27:33 +00004138 ICS.Standard = Best->FinalConversion;
4139 Sequence.AddConversionSequenceStep(ICS, DestType);
4140 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004141}
4142
John McCallf85e1932011-06-15 23:02:42 +00004143/// The non-zero enum values here are indexes into diagnostic alternatives.
4144enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4145
4146/// Determines whether this expression is an acceptable ICR source.
John McCallc03fa492011-06-27 23:59:58 +00004147static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004148 bool isAddressOf, bool &isWeakAccess) {
John McCallf85e1932011-06-15 23:02:42 +00004149 // Skip parens.
4150 e = e->IgnoreParens();
4151
4152 // Skip address-of nodes.
4153 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4154 if (op->getOpcode() == UO_AddrOf)
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004155 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4156 isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004157
4158 // Skip certain casts.
John McCallc03fa492011-06-27 23:59:58 +00004159 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4160 switch (ce->getCastKind()) {
John McCallf85e1932011-06-15 23:02:42 +00004161 case CK_Dependent:
4162 case CK_BitCast:
4163 case CK_LValueBitCast:
John McCallf85e1932011-06-15 23:02:42 +00004164 case CK_NoOp:
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004165 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004166
4167 case CK_ArrayToPointerDecay:
4168 return IIK_nonscalar;
4169
4170 case CK_NullToPointer:
4171 return IIK_okay;
4172
4173 default:
4174 break;
4175 }
4176
4177 // If we have a declaration reference, it had better be a local variable.
John McCallf4b88a42012-03-10 09:33:50 +00004178 } else if (isa<DeclRefExpr>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004179 // set isWeakAccess to true, to mean that there will be an implicit
4180 // load which requires a cleanup.
4181 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4182 isWeakAccess = true;
4183
John McCallc03fa492011-06-27 23:59:58 +00004184 if (!isAddressOf) return IIK_nonlocal;
4185
John McCallf4b88a42012-03-10 09:33:50 +00004186 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4187 if (!var) return IIK_nonlocal;
John McCallc03fa492011-06-27 23:59:58 +00004188
4189 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
John McCallf85e1932011-06-15 23:02:42 +00004190
4191 // If we have a conditional operator, check both sides.
4192 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004193 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4194 isWeakAccess))
John McCallf85e1932011-06-15 23:02:42 +00004195 return iik;
4196
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004197 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004198
4199 // These are never scalar.
4200 } else if (isa<ArraySubscriptExpr>(e)) {
4201 return IIK_nonscalar;
4202
4203 // Otherwise, it needs to be a null pointer constant.
4204 } else {
4205 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4206 ? IIK_okay : IIK_nonlocal);
4207 }
4208
4209 return IIK_nonlocal;
4210}
4211
4212/// Check whether the given expression is a valid operand for an
4213/// indirect copy/restore.
4214static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4215 assert(src->isRValue());
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004216 bool isWeakAccess = false;
4217 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4218 // If isWeakAccess to true, there will be an implicit
4219 // load which requires a cleanup.
4220 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4221 S.ExprNeedsCleanups = true;
4222
John McCallf85e1932011-06-15 23:02:42 +00004223 if (iik == IIK_okay) return;
4224
4225 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4226 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4227 << src->getSourceRange();
4228}
4229
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004230/// \brief Determine whether we have compatible array types for the
4231/// purposes of GNU by-copy array initialization.
4232static bool hasCompatibleArrayTypes(ASTContext &Context,
4233 const ArrayType *Dest,
4234 const ArrayType *Source) {
4235 // If the source and destination array types are equivalent, we're
4236 // done.
4237 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4238 return true;
4239
4240 // Make sure that the element types are the same.
4241 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4242 return false;
4243
4244 // The only mismatch we allow is when the destination is an
4245 // incomplete array type and the source is a constant array type.
4246 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4247}
4248
John McCallf85e1932011-06-15 23:02:42 +00004249static bool tryObjCWritebackConversion(Sema &S,
4250 InitializationSequence &Sequence,
4251 const InitializedEntity &Entity,
4252 Expr *Initializer) {
4253 bool ArrayDecay = false;
4254 QualType ArgType = Initializer->getType();
4255 QualType ArgPointee;
4256 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4257 ArrayDecay = true;
4258 ArgPointee = ArgArrayType->getElementType();
4259 ArgType = S.Context.getPointerType(ArgPointee);
4260 }
4261
4262 // Handle write-back conversion.
4263 QualType ConvertedArgType;
4264 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4265 ConvertedArgType))
4266 return false;
4267
4268 // We should copy unless we're passing to an argument explicitly
4269 // marked 'out'.
4270 bool ShouldCopy = true;
4271 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4272 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4273
4274 // Do we need an lvalue conversion?
4275 if (ArrayDecay || Initializer->isGLValue()) {
4276 ImplicitConversionSequence ICS;
4277 ICS.setStandard();
4278 ICS.Standard.setAsIdentityConversion();
4279
4280 QualType ResultType;
4281 if (ArrayDecay) {
4282 ICS.Standard.First = ICK_Array_To_Pointer;
4283 ResultType = S.Context.getPointerType(ArgPointee);
4284 } else {
4285 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4286 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4287 }
4288
4289 Sequence.AddConversionSequenceStep(ICS, ResultType);
4290 }
4291
4292 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4293 return true;
4294}
4295
Guy Benyei21f18c42013-02-07 10:55:47 +00004296static bool TryOCLSamplerInitialization(Sema &S,
4297 InitializationSequence &Sequence,
4298 QualType DestType,
4299 Expr *Initializer) {
4300 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4301 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4302 return false;
4303
4304 Sequence.AddOCLSamplerInitStep(DestType);
4305 return true;
4306}
4307
Guy Benyeie6b9d802013-01-20 12:31:11 +00004308//
4309// OpenCL 1.2 spec, s6.12.10
4310//
4311// The event argument can also be used to associate the
4312// async_work_group_copy with a previous async copy allowing
4313// an event to be shared by multiple async copies; otherwise
4314// event should be zero.
4315//
4316static bool TryOCLZeroEventInitialization(Sema &S,
4317 InitializationSequence &Sequence,
4318 QualType DestType,
4319 Expr *Initializer) {
4320 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4321 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4322 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4323 return false;
4324
4325 Sequence.AddOCLZeroEventStep(DestType);
4326 return true;
4327}
4328
Douglas Gregor20093b42009-12-09 23:02:17 +00004329InitializationSequence::InitializationSequence(Sema &S,
4330 const InitializedEntity &Entity,
4331 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004332 MultiExprArg Args)
John McCall5769d612010-02-08 23:07:23 +00004333 : FailedCandidateSet(Kind.getLocation()) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004334 ASTContext &Context = S.Context;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004335
John McCall76da55d2013-04-16 07:28:30 +00004336 // Eliminate non-overload placeholder types in the arguments. We
4337 // need to do this before checking whether types are dependent
4338 // because lowering a pseudo-object expression might well give us
4339 // something of dependent type.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004340 for (unsigned I = 0, E = Args.size(); I != E; ++I)
John McCall76da55d2013-04-16 07:28:30 +00004341 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4342 // FIXME: should we be doing this here?
4343 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4344 if (result.isInvalid()) {
4345 SetFailed(FK_PlaceholderType);
4346 return;
4347 }
4348 Args[I] = result.take();
4349 }
4350
Douglas Gregor20093b42009-12-09 23:02:17 +00004351 // C++0x [dcl.init]p16:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004352 // The semantics of initializers are as follows. The destination type is
4353 // the type of the object or reference being initialized and the source
Douglas Gregor20093b42009-12-09 23:02:17 +00004354 // type is the type of the initializer expression. The source type is not
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004355 // defined when the initializer is a braced-init-list or when it is a
Douglas Gregor20093b42009-12-09 23:02:17 +00004356 // parenthesized list of expressions.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004357 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00004358
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004359 if (DestType->isDependentType() ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004360 Expr::hasAnyTypeDependentArguments(Args)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004361 SequenceKind = DependentSequence;
4362 return;
4363 }
4364
Sebastian Redl7491c492011-06-05 13:59:11 +00004365 // Almost everything is a normal sequence.
4366 setSequenceKind(NormalSequence);
4367
Douglas Gregor20093b42009-12-09 23:02:17 +00004368 QualType SourceType;
4369 Expr *Initializer = 0;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004370 if (Args.size() == 1) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004371 Initializer = Args[0];
4372 if (!isa<InitListExpr>(Initializer))
4373 SourceType = Initializer->getType();
4374 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004375
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00004376 // - If the initializer is a (non-parenthesized) braced-init-list, the
4377 // object is list-initialized (8.5.4).
4378 if (Kind.getKind() != InitializationKind::IK_Direct) {
4379 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4380 TryListInitialization(S, Entity, Kind, InitList, *this);
4381 return;
4382 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004383 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004384
Douglas Gregor20093b42009-12-09 23:02:17 +00004385 // - If the destination type is a reference type, see 8.5.3.
4386 if (DestType->isReferenceType()) {
4387 // C++0x [dcl.init.ref]p1:
4388 // A variable declared to be a T& or T&&, that is, "reference to type T"
4389 // (8.3.2), shall be initialized by an object, or function, of type T or
4390 // by an object that can be converted into a T.
4391 // (Therefore, multiple arguments are not permitted.)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004392 if (Args.size() != 1)
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004393 SetFailed(FK_TooManyInitsForReference);
Douglas Gregor20093b42009-12-09 23:02:17 +00004394 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004395 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004396 return;
4397 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004398
Douglas Gregor20093b42009-12-09 23:02:17 +00004399 // - If the initializer is (), the object is value-initialized.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004400 if (Kind.getKind() == InitializationKind::IK_Value ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004401 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004402 TryValueInitialization(S, Entity, Kind, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004403 return;
4404 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004405
Douglas Gregor99a2e602009-12-16 01:38:02 +00004406 // Handle default initialization.
Nick Lewycky7663f392010-11-20 01:29:55 +00004407 if (Kind.getKind() == InitializationKind::IK_Default) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004408 TryDefaultInitialization(S, Entity, Kind, *this);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004409 return;
4410 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004411
John McCallce6c9b72011-02-21 07:22:22 +00004412 // - If the destination type is an array of characters, an array of
4413 // char16_t, an array of char32_t, or an array of wchar_t, and the
4414 // initializer is a string literal, see 8.5.2.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004415 // - Otherwise, if the destination type is an array, the program is
Douglas Gregor20093b42009-12-09 23:02:17 +00004416 // ill-formed.
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004417 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
John McCall73076432012-01-05 00:13:19 +00004418 if (Initializer && isa<VariableArrayType>(DestAT)) {
4419 SetFailed(FK_VariableLengthArrayHasInitializer);
4420 return;
4421 }
4422
Hans Wennborg0ff50742013-05-15 11:03:04 +00004423 if (Initializer) {
4424 switch (IsStringInit(Initializer, DestAT, Context)) {
4425 case SIF_None:
4426 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4427 return;
4428 case SIF_NarrowStringIntoWideChar:
4429 SetFailed(FK_NarrowStringIntoWideCharArray);
4430 return;
4431 case SIF_WideStringIntoChar:
4432 SetFailed(FK_WideStringIntoCharArray);
4433 return;
4434 case SIF_IncompatWideStringIntoWideChar:
4435 SetFailed(FK_IncompatWideStringIntoWideChar);
4436 return;
4437 case SIF_Other:
4438 break;
4439 }
John McCallce6c9b72011-02-21 07:22:22 +00004440 }
4441
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004442 // Note: as an GNU C extension, we allow initialization of an
4443 // array from a compound literal that creates an array of the same
4444 // type, so long as the initializer has no side effects.
David Blaikie4e4d0842012-03-11 07:00:24 +00004445 if (!S.getLangOpts().CPlusPlus && Initializer &&
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004446 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4447 Initializer->getType()->isArrayType()) {
4448 const ArrayType *SourceAT
4449 = Context.getAsArrayType(Initializer->getType());
4450 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004451 SetFailed(FK_ArrayTypeMismatch);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004452 else if (Initializer->HasSideEffects(S.Context))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004453 SetFailed(FK_NonConstantArrayInit);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004454 else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004455 AddArrayInitStep(DestType);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004456 }
Richard Smith0f163e92012-02-15 22:38:09 +00004457 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00004458 // Note: as a GNU C++ extension, we allow list-initialization of a
4459 // class member of array type from a parenthesized initializer list.
David Blaikie4e4d0842012-03-11 07:00:24 +00004460 else if (S.getLangOpts().CPlusPlus &&
Richard Smith0f163e92012-02-15 22:38:09 +00004461 Entity.getKind() == InitializedEntity::EK_Member &&
4462 Initializer && isa<InitListExpr>(Initializer)) {
4463 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4464 *this);
4465 AddParenthesizedArrayInitStep(DestType);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004466 } else if (DestAT->getElementType()->isCharType())
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004467 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004468 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4469 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
Douglas Gregor20093b42009-12-09 23:02:17 +00004470 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004471 SetFailed(FK_ArrayNeedsInitList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004472
Douglas Gregor20093b42009-12-09 23:02:17 +00004473 return;
4474 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004475
John McCallf85e1932011-06-15 23:02:42 +00004476 // Determine whether we should consider writeback conversions for
4477 // Objective-C ARC.
David Blaikie4e4d0842012-03-11 07:00:24 +00004478 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00004479 Entity.getKind() == InitializedEntity::EK_Parameter;
4480
4481 // We're at the end of the line for C: it's either a write-back conversion
4482 // or it's a C assignment. There's no need to check anything else.
David Blaikie4e4d0842012-03-11 07:00:24 +00004483 if (!S.getLangOpts().CPlusPlus) {
John McCallf85e1932011-06-15 23:02:42 +00004484 // If allowed, check whether this is an Objective-C writeback conversion.
4485 if (allowObjCWritebackConversion &&
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004486 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
John McCallf85e1932011-06-15 23:02:42 +00004487 return;
4488 }
Guy Benyei21f18c42013-02-07 10:55:47 +00004489
4490 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4491 return;
Guy Benyeie6b9d802013-01-20 12:31:11 +00004492
4493 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4494 return;
4495
John McCallf85e1932011-06-15 23:02:42 +00004496 // Handle initialization in C
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004497 AddCAssignmentStep(DestType);
4498 MaybeProduceObjCObject(S, *this, Entity);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004499 return;
4500 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004501
David Blaikie4e4d0842012-03-11 07:00:24 +00004502 assert(S.getLangOpts().CPlusPlus);
John McCallf85e1932011-06-15 23:02:42 +00004503
Douglas Gregor20093b42009-12-09 23:02:17 +00004504 // - If the destination type is a (possibly cv-qualified) class type:
4505 if (DestType->isRecordType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004506 // - If the initialization is direct-initialization, or if it is
4507 // copy-initialization where the cv-unqualified version of the
4508 // source type is the same class as, or a derived class of, the
Douglas Gregor20093b42009-12-09 23:02:17 +00004509 // class of the destination, constructors are considered. [...]
4510 if (Kind.getKind() == InitializationKind::IK_Direct ||
4511 (Kind.getKind() == InitializationKind::IK_Copy &&
4512 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4513 S.IsDerivedFrom(SourceType, DestType))))
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004514 TryConstructorInitialization(S, Entity, Kind, Args,
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004515 Entity.getType(), *this);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004516 // - Otherwise (i.e., for the remaining copy-initialization cases),
Douglas Gregor20093b42009-12-09 23:02:17 +00004517 // user-defined conversion sequences that can convert from the source
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004518 // type to the destination type or (when a conversion function is
Douglas Gregor20093b42009-12-09 23:02:17 +00004519 // used) to a derived class thereof are enumerated as described in
4520 // 13.3.1.4, and the best one is chosen through overload resolution
4521 // (13.3).
4522 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004523 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004524 return;
4525 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004526
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004527 if (Args.size() > 1) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004528 SetFailed(FK_TooManyInitsForScalar);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004529 return;
4530 }
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004531 assert(Args.size() == 1 && "Zero-argument case handled above");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004532
4533 // - Otherwise, if the source type is a (possibly cv-qualified) class
Douglas Gregor20093b42009-12-09 23:02:17 +00004534 // type, conversion functions are considered.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004535 if (!SourceType.isNull() && SourceType->isRecordType()) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004536 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
4537 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00004538 return;
4539 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004540
Douglas Gregor20093b42009-12-09 23:02:17 +00004541 // - Otherwise, the initial value of the object being initialized is the
Douglas Gregor4a520a22009-12-14 17:27:33 +00004542 // (possibly converted) value of the initializer expression. Standard
Douglas Gregor20093b42009-12-09 23:02:17 +00004543 // conversions (Clause 4) will be used, if necessary, to convert the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004544 // initializer expression to the cv-unqualified version of the
Douglas Gregor20093b42009-12-09 23:02:17 +00004545 // destination type; no user-defined conversions are considered.
John McCallf85e1932011-06-15 23:02:42 +00004546
4547 ImplicitConversionSequence ICS
4548 = S.TryImplicitConversion(Initializer, Entity.getType(),
4549 /*SuppressUserConversions*/true,
John McCall369371c2010-06-04 02:29:22 +00004550 /*AllowExplicitConversions*/ false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00004551 /*InOverloadResolution*/ false,
John McCallf85e1932011-06-15 23:02:42 +00004552 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4553 allowObjCWritebackConversion);
4554
4555 if (ICS.isStandard() &&
4556 ICS.Standard.Second == ICK_Writeback_Conversion) {
4557 // Objective-C ARC writeback conversion.
4558
4559 // We should copy unless we're passing to an argument explicitly
4560 // marked 'out'.
4561 bool ShouldCopy = true;
4562 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4563 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4564
4565 // If there was an lvalue adjustment, add it as a separate conversion.
4566 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4567 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4568 ImplicitConversionSequence LvalueICS;
4569 LvalueICS.setStandard();
4570 LvalueICS.Standard.setAsIdentityConversion();
4571 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4572 LvalueICS.Standard.First = ICS.Standard.First;
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004573 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
John McCallf85e1932011-06-15 23:02:42 +00004574 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004575
4576 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
John McCallf85e1932011-06-15 23:02:42 +00004577 } else if (ICS.isBad()) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004578 DeclAccessPair dap;
4579 if (Initializer->getType() == Context.OverloadTy &&
4580 !S.ResolveAddressOfOverloadedFunction(Initializer
4581 , DestType, false, dap))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004582 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor8e960432010-11-08 03:40:48 +00004583 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004584 SetFailed(InitializationSequence::FK_ConversionFailed);
John McCallf85e1932011-06-15 23:02:42 +00004585 } else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004586 AddConversionSequenceStep(ICS, Entity.getType());
John McCall856d3792011-06-16 23:24:51 +00004587
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004588 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor8e960432010-11-08 03:40:48 +00004589 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004590}
4591
4592InitializationSequence::~InitializationSequence() {
Chris Lattner5f9e2722011-07-23 10:55:15 +00004593 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
Douglas Gregor20093b42009-12-09 23:02:17 +00004594 StepEnd = Steps.end();
4595 Step != StepEnd; ++Step)
4596 Step->Destroy();
4597}
4598
4599//===----------------------------------------------------------------------===//
4600// Perform initialization
4601//===----------------------------------------------------------------------===//
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004602static Sema::AssignmentAction
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004603getAssignmentAction(const InitializedEntity &Entity) {
4604 switch(Entity.getKind()) {
4605 case InitializedEntity::EK_Variable:
4606 case InitializedEntity::EK_New:
Douglas Gregora3998bd2010-12-02 21:47:04 +00004607 case InitializedEntity::EK_Exception:
4608 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004609 case InitializedEntity::EK_Delegating:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004610 return Sema::AA_Initializing;
4611
4612 case InitializedEntity::EK_Parameter:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004613 if (Entity.getDecl() &&
Douglas Gregor688fc9b2010-04-21 23:24:10 +00004614 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4615 return Sema::AA_Sending;
4616
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004617 return Sema::AA_Passing;
4618
4619 case InitializedEntity::EK_Result:
4620 return Sema::AA_Returning;
4621
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004622 case InitializedEntity::EK_Temporary:
4623 // FIXME: Can we tell apart casting vs. converting?
4624 return Sema::AA_Casting;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004625
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004626 case InitializedEntity::EK_Member:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004627 case InitializedEntity::EK_ArrayElement:
4628 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004629 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004630 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004631 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004632 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004633 return Sema::AA_Initializing;
4634 }
4635
David Blaikie7530c032012-01-17 06:56:22 +00004636 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004637}
4638
Richard Smith774d8b42013-01-08 00:08:23 +00004639/// \brief Whether we should bind a created object as a temporary when
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004640/// initializing the given entity.
Douglas Gregor2f599792010-04-02 18:24:57 +00004641static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004642 switch (Entity.getKind()) {
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004643 case InitializedEntity::EK_ArrayElement:
4644 case InitializedEntity::EK_Member:
Douglas Gregor2f599792010-04-02 18:24:57 +00004645 case InitializedEntity::EK_Result:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004646 case InitializedEntity::EK_New:
4647 case InitializedEntity::EK_Variable:
4648 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004649 case InitializedEntity::EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004650 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004651 case InitializedEntity::EK_ComplexElement:
Anders Carlssona508b7d2010-02-06 23:23:06 +00004652 case InitializedEntity::EK_Exception:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004653 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004654 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004655 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004656 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004657
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004658 case InitializedEntity::EK_Parameter:
4659 case InitializedEntity::EK_Temporary:
4660 return true;
4661 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004662
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004663 llvm_unreachable("missed an InitializedEntity kind?");
4664}
4665
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004666/// \brief Whether the given entity, when initialized with an object
4667/// created for that initialization, requires destruction.
4668static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4669 switch (Entity.getKind()) {
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004670 case InitializedEntity::EK_Result:
4671 case InitializedEntity::EK_New:
4672 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004673 case InitializedEntity::EK_Delegating:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004674 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004675 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004676 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004677 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004678 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004679
Richard Smith774d8b42013-01-08 00:08:23 +00004680 case InitializedEntity::EK_Member:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004681 case InitializedEntity::EK_Variable:
4682 case InitializedEntity::EK_Parameter:
4683 case InitializedEntity::EK_Temporary:
4684 case InitializedEntity::EK_ArrayElement:
4685 case InitializedEntity::EK_Exception:
Jordan Rose2624b812013-05-06 16:48:12 +00004686 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004687 return true;
4688 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004689
4690 llvm_unreachable("missed an InitializedEntity kind?");
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004691}
4692
Richard Smith83da2e72011-10-19 16:55:56 +00004693/// \brief Look for copy and move constructors and constructor templates, for
4694/// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4695static void LookupCopyAndMoveConstructors(Sema &S,
4696 OverloadCandidateSet &CandidateSet,
4697 CXXRecordDecl *Class,
4698 Expr *CurInitExpr) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004699 DeclContext::lookup_result R = S.LookupConstructors(Class);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004700 // The container holding the constructors can under certain conditions
4701 // be changed while iterating (e.g. because of deserialization).
4702 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004703 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004704 for (SmallVector<NamedDecl*, 16>::iterator
4705 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4706 NamedDecl *D = *CI;
Richard Smith83da2e72011-10-19 16:55:56 +00004707 CXXConstructorDecl *Constructor = 0;
4708
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004709 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
Richard Smith83da2e72011-10-19 16:55:56 +00004710 // Handle copy/moveconstructors, only.
4711 if (!Constructor || Constructor->isInvalidDecl() ||
4712 !Constructor->isCopyOrMoveConstructor() ||
4713 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4714 continue;
4715
4716 DeclAccessPair FoundDecl
4717 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4718 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004719 CurInitExpr, CandidateSet);
Richard Smith83da2e72011-10-19 16:55:56 +00004720 continue;
4721 }
4722
4723 // Handle constructor templates.
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004724 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
Richard Smith83da2e72011-10-19 16:55:56 +00004725 if (ConstructorTmpl->isInvalidDecl())
4726 continue;
4727
4728 Constructor = cast<CXXConstructorDecl>(
4729 ConstructorTmpl->getTemplatedDecl());
4730 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4731 continue;
4732
4733 // FIXME: Do we need to limit this to copy-constructor-like
4734 // candidates?
4735 DeclAccessPair FoundDecl
4736 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
4737 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004738 CurInitExpr, CandidateSet, true);
Richard Smith83da2e72011-10-19 16:55:56 +00004739 }
4740}
4741
4742/// \brief Get the location at which initialization diagnostics should appear.
4743static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4744 Expr *Initializer) {
4745 switch (Entity.getKind()) {
4746 case InitializedEntity::EK_Result:
4747 return Entity.getReturnLoc();
4748
4749 case InitializedEntity::EK_Exception:
4750 return Entity.getThrowLoc();
4751
4752 case InitializedEntity::EK_Variable:
4753 return Entity.getDecl()->getLocation();
4754
Douglas Gregor47736542012-02-15 16:57:26 +00004755 case InitializedEntity::EK_LambdaCapture:
4756 return Entity.getCaptureLoc();
4757
Richard Smith83da2e72011-10-19 16:55:56 +00004758 case InitializedEntity::EK_ArrayElement:
4759 case InitializedEntity::EK_Member:
4760 case InitializedEntity::EK_Parameter:
4761 case InitializedEntity::EK_Temporary:
4762 case InitializedEntity::EK_New:
4763 case InitializedEntity::EK_Base:
4764 case InitializedEntity::EK_Delegating:
4765 case InitializedEntity::EK_VectorElement:
4766 case InitializedEntity::EK_ComplexElement:
4767 case InitializedEntity::EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00004768 case InitializedEntity::EK_CompoundLiteralInit:
Richard Smith83da2e72011-10-19 16:55:56 +00004769 return Initializer->getLocStart();
4770 }
4771 llvm_unreachable("missed an InitializedEntity kind?");
4772}
4773
Douglas Gregor523d46a2010-04-18 07:40:54 +00004774/// \brief Make a (potentially elidable) temporary copy of the object
4775/// provided by the given initializer by calling the appropriate copy
4776/// constructor.
4777///
4778/// \param S The Sema object used for type-checking.
4779///
Abramo Bagnara63e7d252011-01-27 19:55:10 +00004780/// \param T The type of the temporary object, which must either be
Douglas Gregor523d46a2010-04-18 07:40:54 +00004781/// the type of the initializer expression or a superclass thereof.
4782///
James Dennett1dfbd922012-06-14 21:40:34 +00004783/// \param Entity The entity being initialized.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004784///
4785/// \param CurInit The initializer expression.
4786///
4787/// \param IsExtraneousCopy Whether this is an "extraneous" copy that
4788/// is permitted in C++03 (but not C++0x) when binding a reference to
4789/// an rvalue.
4790///
4791/// \returns An expression that copies the initializer expression into
4792/// a temporary object, or an error expression if a copy could not be
4793/// created.
John McCall60d7b3a2010-08-24 06:29:42 +00004794static ExprResult CopyObject(Sema &S,
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004795 QualType T,
4796 const InitializedEntity &Entity,
4797 ExprResult CurInit,
4798 bool IsExtraneousCopy) {
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004799 // Determine which class type we're copying to.
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004800 Expr *CurInitExpr = (Expr *)CurInit.get();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004801 CXXRecordDecl *Class = 0;
Douglas Gregor523d46a2010-04-18 07:40:54 +00004802 if (const RecordType *Record = T->getAs<RecordType>())
Douglas Gregor2f599792010-04-02 18:24:57 +00004803 Class = cast<CXXRecordDecl>(Record->getDecl());
4804 if (!Class)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004805 return CurInit;
Douglas Gregor2f599792010-04-02 18:24:57 +00004806
Douglas Gregorf5d8f462011-01-21 18:05:27 +00004807 // C++0x [class.copy]p32:
Douglas Gregor2f599792010-04-02 18:24:57 +00004808 // When certain criteria are met, an implementation is allowed to
4809 // omit the copy/move construction of a class object, even if the
4810 // copy/move constructor and/or destructor for the object have
4811 // side effects. [...]
4812 // - when a temporary class object that has not been bound to a
4813 // reference (12.2) would be copied/moved to a class object
4814 // with the same cv-unqualified type, the copy/move operation
4815 // can be omitted by constructing the temporary object
4816 // directly into the target of the omitted copy/move
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004817 //
Douglas Gregor2f599792010-04-02 18:24:57 +00004818 // Note that the other three bullets are handled elsewhere. Copy
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004819 // elision for return statements and throw expressions are handled as part
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004820 // of constructor initialization, while copy elision for exception handlers
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004821 // is handled by the run-time.
John McCall558d2ab2010-09-15 10:14:12 +00004822 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
Richard Smith83da2e72011-10-19 16:55:56 +00004823 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004824
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004825 // Make sure that the type we are copying is complete.
Douglas Gregord10099e2012-05-04 16:32:21 +00004826 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004827 return CurInit;
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004828
Douglas Gregorcc15f012011-01-21 19:38:21 +00004829 // Perform overload resolution using the class's copy/move constructors.
Richard Smith83da2e72011-10-19 16:55:56 +00004830 // Only consider constructors and constructor templates. Per
4831 // C++0x [dcl.init]p16, second bullet to class types, this initialization
4832 // is direct-initialization.
John McCall5769d612010-02-08 23:07:23 +00004833 OverloadCandidateSet CandidateSet(Loc);
Richard Smith83da2e72011-10-19 16:55:56 +00004834 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004835
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004836 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4837
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004838 OverloadCandidateSet::iterator Best;
Chandler Carruth25ca4212011-02-25 19:41:05 +00004839 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004840 case OR_Success:
4841 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004842
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004843 case OR_No_Viable_Function:
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004844 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
4845 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
4846 : diag::err_temp_copy_no_viable)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004847 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004848 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004849 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004850 if (!IsExtraneousCopy || S.isSFINAEContext())
John McCallf312b1e2010-08-26 23:41:50 +00004851 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004852 return CurInit;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004853
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004854 case OR_Ambiguous:
4855 S.Diag(Loc, diag::err_temp_copy_ambiguous)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004856 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004857 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004858 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
John McCallf312b1e2010-08-26 23:41:50 +00004859 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004860
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004861 case OR_Deleted:
4862 S.Diag(Loc, diag::err_temp_copy_deleted)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004863 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004864 << CurInitExpr->getSourceRange();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004865 S.NoteDeletedFunction(Best->Function);
John McCallf312b1e2010-08-26 23:41:50 +00004866 return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004867 }
4868
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004869 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00004870 SmallVector<Expr*, 8> ConstructorArgs;
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004871 CurInit.release(); // Ownership transferred into MultiExprArg, below.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004872
Anders Carlsson9a68a672010-04-21 18:47:17 +00004873 S.CheckConstructorAccess(Loc, Constructor, Entity,
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004874 Best->FoundDecl.getAccess(), IsExtraneousCopy);
Douglas Gregor523d46a2010-04-18 07:40:54 +00004875
4876 if (IsExtraneousCopy) {
4877 // If this is a totally extraneous copy for C++03 reference
4878 // binding purposes, just return the original initialization
Douglas Gregor2559a702010-04-18 07:57:34 +00004879 // expression. We don't generate an (elided) copy operation here
4880 // because doing so would require us to pass down a flag to avoid
4881 // infinite recursion, where each step adds another extraneous,
4882 // elidable copy.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004883
Douglas Gregor2559a702010-04-18 07:57:34 +00004884 // Instantiate the default arguments of any extra parameters in
4885 // the selected copy constructor, as if we were going to create a
4886 // proper call to the copy constructor.
4887 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
4888 ParmVarDecl *Parm = Constructor->getParamDecl(I);
4889 if (S.RequireCompleteType(Loc, Parm->getType(),
Douglas Gregord10099e2012-05-04 16:32:21 +00004890 diag::err_call_incomplete_argument))
Douglas Gregor2559a702010-04-18 07:57:34 +00004891 break;
4892
4893 // Build the default argument expression; we don't actually care
4894 // if this succeeds or not, because this routine will complain
4895 // if there was a problem.
4896 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
4897 }
4898
Douglas Gregor523d46a2010-04-18 07:40:54 +00004899 return S.Owned(CurInitExpr);
4900 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004901
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004902 // Determine the arguments required to actually perform the
Douglas Gregor523d46a2010-04-18 07:40:54 +00004903 // constructor call (we might have derived-to-base conversions, or
4904 // the copy constructor may have default arguments).
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004905 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00004906 return ExprError();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004907
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00004908 // Actually perform the constructor call.
4909 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004910 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004911 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00004912 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00004913 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00004914 CXXConstructExpr::CK_Complete,
4915 SourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004916
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00004917 // If we're supposed to bind temporaries, do so.
4918 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
4919 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004920 return CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004921}
Douglas Gregor20093b42009-12-09 23:02:17 +00004922
Richard Smith83da2e72011-10-19 16:55:56 +00004923/// \brief Check whether elidable copy construction for binding a reference to
4924/// a temporary would have succeeded if we were building in C++98 mode, for
4925/// -Wc++98-compat.
4926static void CheckCXX98CompatAccessibleCopy(Sema &S,
4927 const InitializedEntity &Entity,
4928 Expr *CurInitExpr) {
Richard Smith80ad52f2013-01-02 11:42:31 +00004929 assert(S.getLangOpts().CPlusPlus11);
Richard Smith83da2e72011-10-19 16:55:56 +00004930
4931 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
4932 if (!Record)
4933 return;
4934
4935 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
4936 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc)
4937 == DiagnosticsEngine::Ignored)
4938 return;
4939
4940 // Find constructors which would have been considered.
4941 OverloadCandidateSet CandidateSet(Loc);
4942 LookupCopyAndMoveConstructors(
4943 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
4944
4945 // Perform overload resolution.
4946 OverloadCandidateSet::iterator Best;
4947 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
4948
4949 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
4950 << OR << (int)Entity.getKind() << CurInitExpr->getType()
4951 << CurInitExpr->getSourceRange();
4952
4953 switch (OR) {
4954 case OR_Success:
4955 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
John McCallb9abd8722012-04-07 03:04:20 +00004956 Entity, Best->FoundDecl.getAccess(), Diag);
Richard Smith83da2e72011-10-19 16:55:56 +00004957 // FIXME: Check default arguments as far as that's possible.
4958 break;
4959
4960 case OR_No_Viable_Function:
4961 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00004962 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00004963 break;
4964
4965 case OR_Ambiguous:
4966 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00004967 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00004968 break;
4969
4970 case OR_Deleted:
4971 S.Diag(Loc, Diag);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004972 S.NoteDeletedFunction(Best->Function);
Richard Smith83da2e72011-10-19 16:55:56 +00004973 break;
4974 }
4975}
4976
Douglas Gregora41a8c52010-04-22 00:20:18 +00004977void InitializationSequence::PrintInitLocationNote(Sema &S,
4978 const InitializedEntity &Entity) {
4979 if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) {
4980 if (Entity.getDecl()->getLocation().isInvalid())
4981 return;
4982
4983 if (Entity.getDecl()->getDeclName())
4984 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
4985 << Entity.getDecl()->getDeclName();
4986 else
4987 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
4988 }
4989}
4990
Sebastian Redl3b802322011-07-14 19:07:55 +00004991static bool isReferenceBinding(const InitializationSequence::Step &s) {
4992 return s.Kind == InitializationSequence::SK_BindReference ||
4993 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
4994}
4995
Jordan Rose2624b812013-05-06 16:48:12 +00004996/// Returns true if the parameters describe a constructor initialization of
4997/// an explicit temporary object, e.g. "Point(x, y)".
4998static bool isExplicitTemporary(const InitializedEntity &Entity,
4999 const InitializationKind &Kind,
5000 unsigned NumArgs) {
5001 switch (Entity.getKind()) {
5002 case InitializedEntity::EK_Temporary:
5003 case InitializedEntity::EK_CompoundLiteralInit:
5004 break;
5005 default:
5006 return false;
5007 }
5008
5009 switch (Kind.getKind()) {
5010 case InitializationKind::IK_DirectList:
5011 return true;
5012 // FIXME: Hack to work around cast weirdness.
5013 case InitializationKind::IK_Direct:
5014 case InitializationKind::IK_Value:
5015 return NumArgs != 1;
5016 default:
5017 return false;
5018 }
5019}
5020
Sebastian Redl10f04a62011-12-22 14:44:04 +00005021static ExprResult
5022PerformConstructorInitialization(Sema &S,
5023 const InitializedEntity &Entity,
5024 const InitializationKind &Kind,
5025 MultiExprArg Args,
5026 const InitializationSequence::Step& Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005027 bool &ConstructorInitRequiresZeroInit,
5028 bool IsListInitialization) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005029 unsigned NumArgs = Args.size();
5030 CXXConstructorDecl *Constructor
5031 = cast<CXXConstructorDecl>(Step.Function.Function);
5032 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5033
5034 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005035 SmallVector<Expr*, 8> ConstructorArgs;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005036 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5037 ? Kind.getEqualLoc()
5038 : Kind.getLocation();
5039
5040 if (Kind.getKind() == InitializationKind::IK_Default) {
5041 // Force even a trivial, implicit default constructor to be
5042 // semantically checked. We do this explicitly because we don't build
5043 // the definition for completely trivial constructors.
Matt Beaumont-Gay28e47022012-02-24 08:37:56 +00005044 assert(Constructor->getParent() && "No parent class for constructor.");
Sebastian Redl10f04a62011-12-22 14:44:04 +00005045 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Douglas Gregor5d86f612012-02-24 07:48:37 +00005046 Constructor->isTrivial() && !Constructor->isUsed(false))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005047 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5048 }
5049
5050 ExprResult CurInit = S.Owned((Expr *)0);
5051
Douglas Gregored878af2012-02-24 23:56:31 +00005052 // C++ [over.match.copy]p1:
5053 // - When initializing a temporary to be bound to the first parameter
5054 // of a constructor that takes a reference to possibly cv-qualified
5055 // T as its first argument, called with a single argument in the
5056 // context of direct-initialization, explicit conversion functions
5057 // are also considered.
5058 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5059 Args.size() == 1 &&
5060 Constructor->isCopyOrMoveConstructor();
5061
Sebastian Redl10f04a62011-12-22 14:44:04 +00005062 // Determine the arguments required to actually perform the constructor
5063 // call.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005064 if (S.CompleteConstructorCall(Constructor, Args,
Douglas Gregored878af2012-02-24 23:56:31 +00005065 Loc, ConstructorArgs,
Richard Smitha4dc51b2013-02-05 05:52:24 +00005066 AllowExplicitConv,
5067 IsListInitialization))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005068 return ExprError();
5069
5070
Jordan Rose2624b812013-05-06 16:48:12 +00005071 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005072 // An explicitly-constructed temporary, e.g., X(1, 2).
Eli Friedman5f2987c2012-02-02 03:46:19 +00005073 S.MarkFunctionReferenced(Loc, Constructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005074 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5075 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005076
5077 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5078 if (!TSInfo)
5079 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
Sebastian Redl188158d2012-03-08 21:05:45 +00005080 SourceRange ParenRange;
5081 if (Kind.getKind() != InitializationKind::IK_DirectList)
5082 ParenRange = Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005083
Richard Smithc83c2302012-12-19 01:39:02 +00005084 CurInit = S.Owned(
5085 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor,
5086 TSInfo, ConstructorArgs,
5087 ParenRange, IsListInitialization,
5088 HadMultipleCandidates,
5089 ConstructorInitRequiresZeroInit));
Sebastian Redl10f04a62011-12-22 14:44:04 +00005090 } else {
5091 CXXConstructExpr::ConstructionKind ConstructKind =
5092 CXXConstructExpr::CK_Complete;
5093
5094 if (Entity.getKind() == InitializedEntity::EK_Base) {
5095 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5096 CXXConstructExpr::CK_VirtualBase :
5097 CXXConstructExpr::CK_NonVirtualBase;
5098 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5099 ConstructKind = CXXConstructExpr::CK_Delegating;
5100 }
5101
5102 // Only get the parenthesis range if it is a direct construction.
5103 SourceRange parenRange =
5104 Kind.getKind() == InitializationKind::IK_Direct ?
5105 Kind.getParenRange() : SourceRange();
5106
5107 // If the entity allows NRVO, mark the construction as elidable
5108 // unconditionally.
5109 if (Entity.allowsNRVO())
5110 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5111 Constructor, /*Elidable=*/true,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005112 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005113 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005114 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005115 ConstructorInitRequiresZeroInit,
5116 ConstructKind,
5117 parenRange);
5118 else
5119 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5120 Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005121 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005122 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005123 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005124 ConstructorInitRequiresZeroInit,
5125 ConstructKind,
5126 parenRange);
5127 }
5128 if (CurInit.isInvalid())
5129 return ExprError();
5130
5131 // Only check access if all of that succeeded.
5132 S.CheckConstructorAccess(Loc, Constructor, Entity,
5133 Step.Function.FoundDecl.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005134 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5135 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005136
5137 if (shouldBindAsTemporary(Entity))
5138 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
5139
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005140 return CurInit;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005141}
5142
Richard Smith36d02af2012-06-04 22:27:30 +00005143/// Determine whether the specified InitializedEntity definitely has a lifetime
5144/// longer than the current full-expression. Conservatively returns false if
5145/// it's unclear.
5146static bool
5147InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5148 const InitializedEntity *Top = &Entity;
5149 while (Top->getParent())
5150 Top = Top->getParent();
5151
5152 switch (Top->getKind()) {
5153 case InitializedEntity::EK_Variable:
5154 case InitializedEntity::EK_Result:
5155 case InitializedEntity::EK_Exception:
5156 case InitializedEntity::EK_Member:
5157 case InitializedEntity::EK_New:
5158 case InitializedEntity::EK_Base:
5159 case InitializedEntity::EK_Delegating:
5160 return true;
5161
5162 case InitializedEntity::EK_ArrayElement:
5163 case InitializedEntity::EK_VectorElement:
5164 case InitializedEntity::EK_BlockElement:
5165 case InitializedEntity::EK_ComplexElement:
5166 // Could not determine what the full initialization is. Assume it might not
5167 // outlive the full-expression.
5168 return false;
5169
5170 case InitializedEntity::EK_Parameter:
5171 case InitializedEntity::EK_Temporary:
5172 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00005173 case InitializedEntity::EK_CompoundLiteralInit:
Richard Smith36d02af2012-06-04 22:27:30 +00005174 // The entity being initialized might not outlive the full-expression.
5175 return false;
5176 }
5177
5178 llvm_unreachable("unknown entity kind");
5179}
5180
Richard Smith211c8dd2013-06-05 00:46:14 +00005181/// Determine the declaration which an initialized entity ultimately refers to,
5182/// for the purpose of lifetime-extending a temporary bound to a reference in
5183/// the initialization of \p Entity.
5184static const ValueDecl *
5185getDeclForTemporaryLifetimeExtension(const InitializedEntity &Entity,
5186 const ValueDecl *FallbackDecl = 0) {
5187 // C++11 [class.temporary]p5:
5188 switch (Entity.getKind()) {
5189 case InitializedEntity::EK_Variable:
5190 // The temporary [...] persists for the lifetime of the reference
5191 return Entity.getDecl();
5192
5193 case InitializedEntity::EK_Member:
5194 // For subobjects, we look at the complete object.
5195 if (Entity.getParent())
5196 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5197 Entity.getDecl());
5198
5199 // except:
5200 // -- A temporary bound to a reference member in a constructor's
5201 // ctor-initializer persists until the constructor exits.
5202 return Entity.getDecl();
5203
5204 case InitializedEntity::EK_Parameter:
5205 // -- A temporary bound to a reference parameter in a function call
5206 // persists until the completion of the full-expression containing
5207 // the call.
5208 case InitializedEntity::EK_Result:
5209 // -- The lifetime of a temporary bound to the returned value in a
5210 // function return statement is not extended; the temporary is
5211 // destroyed at the end of the full-expression in the return statement.
5212 case InitializedEntity::EK_New:
5213 // -- A temporary bound to a reference in a new-initializer persists
5214 // until the completion of the full-expression containing the
5215 // new-initializer.
5216 return 0;
5217
5218 case InitializedEntity::EK_Temporary:
5219 case InitializedEntity::EK_CompoundLiteralInit:
5220 // We don't yet know the storage duration of the surrounding temporary.
5221 // Assume it's got full-expression duration for now, it will patch up our
5222 // storage duration if that's not correct.
5223 return 0;
5224
5225 case InitializedEntity::EK_ArrayElement:
5226 // For subobjects, we look at the complete object.
5227 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5228 FallbackDecl);
5229
5230 case InitializedEntity::EK_Base:
5231 case InitializedEntity::EK_Delegating:
5232 // We can reach this case for aggregate initialization in a constructor:
5233 // struct A { int &&r; };
5234 // struct B : A { B() : A{0} {} };
5235 // In this case, use the innermost field decl as the context.
5236 return FallbackDecl;
5237
5238 case InitializedEntity::EK_BlockElement:
5239 case InitializedEntity::EK_LambdaCapture:
5240 case InitializedEntity::EK_Exception:
5241 case InitializedEntity::EK_VectorElement:
5242 case InitializedEntity::EK_ComplexElement:
5243 llvm_unreachable("should not materialize a temporary to initialize this");
5244 }
Benjamin Kramer6f773e82013-06-05 15:37:50 +00005245 llvm_unreachable("unknown entity kind");
Richard Smith211c8dd2013-06-05 00:46:14 +00005246}
5247
5248static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD);
5249
5250/// Update a glvalue expression that is used as the initializer of a reference
5251/// to note that its lifetime is extended.
5252static void performReferenceExtension(Expr *Init, const ValueDecl *ExtendingD) {
5253 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5254 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5255 // This is just redundant braces around an initializer. Step over it.
5256 Init = ILE->getInit(0);
5257 }
5258 }
5259
5260 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5261 // Update the storage duration of the materialized temporary.
5262 // FIXME: Rebuild the expression instead of mutating it.
5263 ME->setExtendingDecl(ExtendingD);
5264 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingD);
5265 }
5266}
5267
5268/// Update a prvalue expression that is going to be materialized as a
5269/// lifetime-extended temporary.
5270static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD) {
5271 // Dig out the expression which constructs the extended temporary.
5272 SmallVector<const Expr *, 2> CommaLHSs;
5273 SmallVector<SubobjectAdjustment, 2> Adjustments;
5274 Init = const_cast<Expr *>(
5275 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5276
Richard Smith8a07cd32013-06-12 20:42:33 +00005277 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5278 Init = BTE->getSubExpr();
5279
Richard Smith211c8dd2013-06-05 00:46:14 +00005280 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
Richard Smithb6e38082013-06-08 00:02:08 +00005281 if (ILE->initializesStdInitializerList() || ILE->getType()->isArrayType()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005282 // FIXME: If this is an InitListExpr which creates a std::initializer_list
5283 // object, we also need to lifetime-extend the underlying array
5284 // itself. Fix the representation to explicitly materialize an
5285 // array temporary so we can model this properly.
5286 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5287 performLifetimeExtension(ILE->getInit(I), ExtendingD);
5288 return;
5289 }
5290
Richard Smithb6e38082013-06-08 00:02:08 +00005291 CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl();
Richard Smith211c8dd2013-06-05 00:46:14 +00005292 if (RD) {
5293 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5294
5295 // If we lifetime-extend a braced initializer which is initializing an
5296 // aggregate, and that aggregate contains reference members which are
5297 // bound to temporaries, those temporaries are also lifetime-extended.
5298 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5299 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5300 performReferenceExtension(ILE->getInit(0), ExtendingD);
5301 else {
5302 unsigned Index = 0;
5303 for (RecordDecl::field_iterator I = RD->field_begin(),
5304 E = RD->field_end();
5305 I != E; ++I) {
5306 if (I->isUnnamedBitfield())
5307 continue;
5308 if (I->getType()->isReferenceType())
5309 performReferenceExtension(ILE->getInit(Index), ExtendingD);
5310 else if (isa<InitListExpr>(ILE->getInit(Index)))
5311 // This may be either aggregate-initialization of a member or
5312 // initialization of a std::initializer_list object. Either way,
5313 // we should recursively lifetime-extend that initializer.
5314 performLifetimeExtension(ILE->getInit(Index), ExtendingD);
5315 ++Index;
5316 }
5317 }
5318 }
5319 }
5320}
5321
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005322ExprResult
Douglas Gregor20093b42009-12-09 23:02:17 +00005323InitializationSequence::Perform(Sema &S,
5324 const InitializedEntity &Entity,
5325 const InitializationKind &Kind,
John McCallf312b1e2010-08-26 23:41:50 +00005326 MultiExprArg Args,
Douglas Gregord87b61f2009-12-10 17:56:55 +00005327 QualType *ResultType) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00005328 if (Failed()) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00005329 Diagnose(S, Entity, Kind, Args);
John McCallf312b1e2010-08-26 23:41:50 +00005330 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005331 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005332
Sebastian Redl7491c492011-06-05 13:59:11 +00005333 if (getKind() == DependentSequence) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005334 // If the declaration is a non-dependent, incomplete array type
5335 // that has an initializer, then its type will be completed once
5336 // the initializer is instantiated.
Douglas Gregord6542d82009-12-22 15:35:07 +00005337 if (ResultType && !Entity.getType()->isDependentType() &&
Douglas Gregord87b61f2009-12-10 17:56:55 +00005338 Args.size() == 1) {
Douglas Gregord6542d82009-12-22 15:35:07 +00005339 QualType DeclType = Entity.getType();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005340 if (const IncompleteArrayType *ArrayT
5341 = S.Context.getAsIncompleteArrayType(DeclType)) {
5342 // FIXME: We don't currently have the ability to accurately
5343 // compute the length of an initializer list without
5344 // performing full type-checking of the initializer list
5345 // (since we have to determine where braces are implicitly
5346 // introduced and such). So, we fall back to making the array
5347 // type a dependently-sized array type with no specified
5348 // bound.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005349 if (isa<InitListExpr>((Expr *)Args[0])) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005350 SourceRange Brackets;
Douglas Gregord6542d82009-12-22 15:35:07 +00005351
Douglas Gregord87b61f2009-12-10 17:56:55 +00005352 // Scavange the location of the brackets from the entity, if we can.
Douglas Gregord6542d82009-12-22 15:35:07 +00005353 if (DeclaratorDecl *DD = Entity.getDecl()) {
5354 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
5355 TypeLoc TL = TInfo->getTypeLoc();
David Blaikie39e6ab42013-02-18 22:06:02 +00005356 if (IncompleteArrayTypeLoc ArrayLoc =
5357 TL.getAs<IncompleteArrayTypeLoc>())
5358 Brackets = ArrayLoc.getBracketsRange();
Douglas Gregord6542d82009-12-22 15:35:07 +00005359 }
Douglas Gregord87b61f2009-12-10 17:56:55 +00005360 }
5361
5362 *ResultType
5363 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
5364 /*NumElts=*/0,
5365 ArrayT->getSizeModifier(),
5366 ArrayT->getIndexTypeCVRQualifiers(),
5367 Brackets);
5368 }
5369
5370 }
5371 }
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005372 if (Kind.getKind() == InitializationKind::IK_Direct &&
5373 !Kind.isExplicitCast()) {
5374 // Rebuild the ParenListExpr.
5375 SourceRange ParenRange = Kind.getParenRange();
5376 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005377 Args);
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005378 }
Manuel Klimek0d9106f2011-06-22 20:02:16 +00005379 assert(Kind.getKind() == InitializationKind::IK_Copy ||
Douglas Gregora9b55a42012-04-04 04:06:51 +00005380 Kind.isExplicitCast() ||
5381 Kind.getKind() == InitializationKind::IK_DirectList);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005382 return ExprResult(Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00005383 }
5384
Sebastian Redl7491c492011-06-05 13:59:11 +00005385 // No steps means no initialization.
5386 if (Steps.empty())
Douglas Gregor99a2e602009-12-16 01:38:02 +00005387 return S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005388
Richard Smith80ad52f2013-01-02 11:42:31 +00005389 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005390 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
Richard Smith03544fc2012-04-19 06:58:00 +00005391 Entity.getKind() != InitializedEntity::EK_Parameter) {
5392 // Produce a C++98 compatibility warning if we are initializing a reference
5393 // from an initializer list. For parameters, we produce a better warning
5394 // elsewhere.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005395 Expr *Init = Args[0];
Richard Smith03544fc2012-04-19 06:58:00 +00005396 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
5397 << Init->getSourceRange();
5398 }
5399
Richard Smith36d02af2012-06-04 22:27:30 +00005400 // Diagnose cases where we initialize a pointer to an array temporary, and the
5401 // pointer obviously outlives the temporary.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005402 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Richard Smith36d02af2012-06-04 22:27:30 +00005403 Entity.getType()->isPointerType() &&
5404 InitializedEntityOutlivesFullExpression(Entity)) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005405 Expr *Init = Args[0];
Richard Smith36d02af2012-06-04 22:27:30 +00005406 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
5407 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
5408 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
5409 << Init->getSourceRange();
5410 }
5411
Douglas Gregord6542d82009-12-22 15:35:07 +00005412 QualType DestType = Entity.getType().getNonReferenceType();
5413 // FIXME: Ugly hack around the fact that Entity.getType() is not
Eli Friedmana91eb542009-12-22 02:10:53 +00005414 // the same as Entity.getDecl()->getType() in cases involving type merging,
5415 // and we want latter when it makes sense.
Douglas Gregord87b61f2009-12-10 17:56:55 +00005416 if (ResultType)
Eli Friedmana91eb542009-12-22 02:10:53 +00005417 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
Douglas Gregord6542d82009-12-22 15:35:07 +00005418 Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005419
John McCall60d7b3a2010-08-24 06:29:42 +00005420 ExprResult CurInit = S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005421
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005422 // For initialization steps that start with a single initializer,
Douglas Gregor99a2e602009-12-16 01:38:02 +00005423 // grab the only argument out the Args and place it into the "current"
5424 // initializer.
5425 switch (Steps.front().Kind) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005426 case SK_ResolveAddressOfOverloadedFunction:
5427 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005428 case SK_CastDerivedToBaseXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005429 case SK_CastDerivedToBaseLValue:
5430 case SK_BindReference:
5431 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00005432 case SK_ExtraneousCopyToTemporary:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005433 case SK_UserConversion:
5434 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005435 case SK_QualificationConversionXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005436 case SK_QualificationConversionRValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00005437 case SK_LValueToRValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005438 case SK_ConversionSequence:
5439 case SK_ListInitialization:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005440 case SK_UnwrapInitList:
5441 case SK_RewrapInitList:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005442 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005443 case SK_StringInit:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005444 case SK_ObjCObjectConversion:
John McCallf85e1932011-06-15 23:02:42 +00005445 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00005446 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00005447 case SK_PassByIndirectCopyRestore:
5448 case SK_PassByIndirectRestore:
Sebastian Redl2b916b82012-01-17 22:49:42 +00005449 case SK_ProduceObjCObject:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005450 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00005451 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005452 case SK_OCLZeroEvent: {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005453 assert(Args.size() == 1);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005454 CurInit = Args[0];
John Wiegley429bb272011-04-08 18:41:53 +00005455 if (!CurInit.get()) return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005456 break;
John McCallf6a16482010-12-04 03:47:34 +00005457 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005458
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005459 case SK_ConstructorInitialization:
Richard Smithf4bb8d02012-07-05 08:39:21 +00005460 case SK_ListConstructorCall:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005461 case SK_ZeroInitialization:
5462 break;
Douglas Gregor20093b42009-12-09 23:02:17 +00005463 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005464
5465 // Walk through the computed steps for the initialization sequence,
Douglas Gregor20093b42009-12-09 23:02:17 +00005466 // performing the specified conversions along the way.
Douglas Gregor16006c92009-12-16 18:50:27 +00005467 bool ConstructorInitRequiresZeroInit = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00005468 for (step_iterator Step = step_begin(), StepEnd = step_end();
5469 Step != StepEnd; ++Step) {
5470 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005471 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005472
John Wiegley429bb272011-04-08 18:41:53 +00005473 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005474
Douglas Gregor20093b42009-12-09 23:02:17 +00005475 switch (Step->Kind) {
5476 case SK_ResolveAddressOfOverloadedFunction:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005477 // Overload resolution determined which function invoke; update the
Douglas Gregor20093b42009-12-09 23:02:17 +00005478 // initializer to reflect that choice.
John Wiegley429bb272011-04-08 18:41:53 +00005479 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
Richard Smith82f145d2013-05-04 06:44:46 +00005480 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
5481 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005482 CurInit = S.FixOverloadedFunctionReference(CurInit,
John McCall6bb80172010-03-30 21:47:33 +00005483 Step->Function.FoundDecl,
John McCall9aa472c2010-03-19 07:35:19 +00005484 Step->Function.Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00005485 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005486
Douglas Gregor20093b42009-12-09 23:02:17 +00005487 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005488 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00005489 case SK_CastDerivedToBaseLValue: {
5490 // We have a derived-to-base cast that produces either an rvalue or an
5491 // lvalue. Perform that cast.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005492
John McCallf871d0c2010-08-07 06:22:56 +00005493 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005494
Douglas Gregor20093b42009-12-09 23:02:17 +00005495 // Casts to inaccessible base classes are allowed with C-style casts.
5496 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
5497 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
John Wiegley429bb272011-04-08 18:41:53 +00005498 CurInit.get()->getLocStart(),
5499 CurInit.get()->getSourceRange(),
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005500 &BasePath, IgnoreBaseAccess))
John McCallf312b1e2010-08-26 23:41:50 +00005501 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005502
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005503 if (S.BasePathInvolvesVirtualBase(BasePath)) {
5504 QualType T = SourceType;
5505 if (const PointerType *Pointer = T->getAs<PointerType>())
5506 T = Pointer->getPointeeType();
5507 if (const RecordType *RecordTy = T->getAs<RecordType>())
John Wiegley429bb272011-04-08 18:41:53 +00005508 S.MarkVTableUsed(CurInit.get()->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005509 cast<CXXRecordDecl>(RecordTy->getDecl()));
5510 }
5511
John McCall5baba9d2010-08-25 10:28:54 +00005512 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005513 Step->Kind == SK_CastDerivedToBaseLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005514 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005515 (Step->Kind == SK_CastDerivedToBaseXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005516 VK_XValue :
5517 VK_RValue);
John McCallf871d0c2010-08-07 06:22:56 +00005518 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5519 Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005520 CK_DerivedToBase,
John McCall5baba9d2010-08-25 10:28:54 +00005521 CurInit.get(),
5522 &BasePath, VK));
Douglas Gregor20093b42009-12-09 23:02:17 +00005523 break;
5524 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005525
Douglas Gregor20093b42009-12-09 23:02:17 +00005526 case SK_BindReference:
John McCall993f43f2013-05-06 21:39:12 +00005527 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
5528 if (CurInit.get()->refersToBitField()) {
5529 // We don't necessarily have an unambiguous source bit-field.
5530 FieldDecl *BitField = CurInit.get()->getSourceBitField();
Douglas Gregor20093b42009-12-09 23:02:17 +00005531 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
Douglas Gregord6542d82009-12-22 15:35:07 +00005532 << Entity.getType().isVolatileQualified()
John McCall993f43f2013-05-06 21:39:12 +00005533 << (BitField ? BitField->getDeclName() : DeclarationName())
5534 << (BitField != NULL)
John Wiegley429bb272011-04-08 18:41:53 +00005535 << CurInit.get()->getSourceRange();
John McCall993f43f2013-05-06 21:39:12 +00005536 if (BitField)
5537 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
5538
John McCallf312b1e2010-08-26 23:41:50 +00005539 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005540 }
Anders Carlssona6fe0bf2010-01-29 02:47:33 +00005541
John Wiegley429bb272011-04-08 18:41:53 +00005542 if (CurInit.get()->refersToVectorElement()) {
John McCall41593e32010-02-02 19:02:38 +00005543 // References cannot bind to vector elements.
Anders Carlsson09380262010-01-31 17:18:49 +00005544 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5545 << Entity.getType().isVolatileQualified()
John Wiegley429bb272011-04-08 18:41:53 +00005546 << CurInit.get()->getSourceRange();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005547 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005548 return ExprError();
Anders Carlsson09380262010-01-31 17:18:49 +00005549 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005550
Douglas Gregor20093b42009-12-09 23:02:17 +00005551 // Reference binding does not have any corresponding ASTs.
5552
5553 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005554 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005555 return ExprError();
Anders Carlsson3aba0932010-01-31 18:34:51 +00005556
Douglas Gregor20093b42009-12-09 23:02:17 +00005557 break;
Anders Carlsson3aba0932010-01-31 18:34:51 +00005558
Richard Smith211c8dd2013-06-05 00:46:14 +00005559 case SK_BindReferenceToTemporary: {
Jordan Rose1fd1e282013-04-11 00:58:58 +00005560 // Make sure the "temporary" is actually an rvalue.
5561 assert(CurInit.get()->isRValue() && "not a temporary");
5562
Douglas Gregor20093b42009-12-09 23:02:17 +00005563 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005564 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005565 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005566
Richard Smith211c8dd2013-06-05 00:46:14 +00005567 // Maybe lifetime-extend the temporary's subobjects to match the
5568 // entity's lifetime.
5569 const ValueDecl *ExtendingDecl =
5570 getDeclForTemporaryLifetimeExtension(Entity);
Richard Smitha4bb99c2013-06-12 21:51:50 +00005571 if (ExtendingDecl) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005572 performLifetimeExtension(CurInit.get(), ExtendingDecl);
5573
Richard Smitha4bb99c2013-06-12 21:51:50 +00005574 // Warn if a field lifetime-extends a temporary.
5575 if (isa<FieldDecl>(ExtendingDecl)) {
5576 bool IsSubobjectMember = false;
5577 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5578 Ent = Ent->getParent()) {
5579 if (Ent->getKind() != InitializedEntity::EK_Base) {
5580 IsSubobjectMember = true;
5581 break;
5582 }
5583 }
5584 S.Diag(CurInit.get()->getExprLoc(),
5585 diag::warn_bind_ref_member_to_temporary)
5586 << ExtendingDecl << CurInit.get()->getSourceRange()
5587 << IsSubobjectMember;
5588 if (IsSubobjectMember)
5589 S.Diag(ExtendingDecl->getLocation(),
5590 diag::note_ref_subobject_of_member_declared_here);
5591 else
5592 S.Diag(ExtendingDecl->getLocation(),
5593 diag::note_ref_or_ptr_member_declared_here)
5594 << /*IsPointer*/false;
5595 }
5596 }
5597
Douglas Gregor03e80032011-06-21 17:03:29 +00005598 // Materialize the temporary into memory.
Richard Smith8a07cd32013-06-12 20:42:33 +00005599 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
Richard Smith211c8dd2013-06-05 00:46:14 +00005600 Entity.getType().getNonReferenceType(), CurInit.get(),
5601 Entity.getType()->isLValueReferenceType(), ExtendingDecl);
Douglas Gregord7b23162011-06-22 16:12:01 +00005602
5603 // If we're binding to an Objective-C object that has lifetime, we
Richard Smith8a07cd32013-06-12 20:42:33 +00005604 // need cleanups. Likewise if we're extending this temporary to automatic
5605 // storage duration -- we need to register its cleanup during the
5606 // full-expression's cleanups.
5607 if ((S.getLangOpts().ObjCAutoRefCount &&
5608 MTE->getType()->isObjCLifetimeType()) ||
5609 (MTE->getStorageDuration() == SD_Automatic &&
5610 MTE->getType().isDestructedType()))
Douglas Gregord7b23162011-06-22 16:12:01 +00005611 S.ExprNeedsCleanups = true;
Richard Smith8a07cd32013-06-12 20:42:33 +00005612
5613 CurInit = S.Owned(MTE);
Douglas Gregor20093b42009-12-09 23:02:17 +00005614 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00005615 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005616
Douglas Gregor523d46a2010-04-18 07:40:54 +00005617 case SK_ExtraneousCopyToTemporary:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005618 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
Douglas Gregor523d46a2010-04-18 07:40:54 +00005619 /*IsExtraneousCopy=*/true);
5620 break;
5621
Douglas Gregor20093b42009-12-09 23:02:17 +00005622 case SK_UserConversion: {
5623 // We have a user-defined conversion that invokes either a constructor
5624 // or a conversion function.
John McCalldaa8e4e2010-11-15 09:13:47 +00005625 CastKind CastKind;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005626 bool IsCopy = false;
John McCall9aa472c2010-03-19 07:35:19 +00005627 FunctionDecl *Fn = Step->Function.Function;
5628 DeclAccessPair FoundFn = Step->Function.FoundDecl;
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005629 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005630 bool CreatedObject = false;
John McCallb13b7372010-02-01 03:16:54 +00005631 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00005632 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005633 SmallVector<Expr*, 8> ConstructorArgs;
John Wiegley429bb272011-04-08 18:41:53 +00005634 SourceLocation Loc = CurInit.get()->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00005635 CurInit.release(); // Ownership transferred into MultiExprArg, below.
John McCallb13b7372010-02-01 03:16:54 +00005636
Douglas Gregor20093b42009-12-09 23:02:17 +00005637 // Determine the arguments required to actually perform the constructor
5638 // call.
John Wiegley429bb272011-04-08 18:41:53 +00005639 Expr *Arg = CurInit.get();
Douglas Gregor20093b42009-12-09 23:02:17 +00005640 if (S.CompleteConstructorCall(Constructor,
John Wiegley429bb272011-04-08 18:41:53 +00005641 MultiExprArg(&Arg, 1),
Douglas Gregor20093b42009-12-09 23:02:17 +00005642 Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005643 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005644
Richard Smithf2e4dfc2012-02-11 19:22:50 +00005645 // Build an expression that constructs a temporary.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005646 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005647 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005648 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005649 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005650 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005651 CXXConstructExpr::CK_Complete,
5652 SourceRange());
Douglas Gregor20093b42009-12-09 23:02:17 +00005653 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005654 return ExprError();
John McCallb13b7372010-02-01 03:16:54 +00005655
Anders Carlsson9a68a672010-04-21 18:47:17 +00005656 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
John McCall9aa472c2010-03-19 07:35:19 +00005657 FoundFn.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005658 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5659 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005660
John McCall2de56d12010-08-25 11:45:40 +00005661 CastKind = CK_ConstructorConversion;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005662 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5663 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5664 S.IsDerivedFrom(SourceType, Class))
5665 IsCopy = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005666
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005667 CreatedObject = true;
Douglas Gregor20093b42009-12-09 23:02:17 +00005668 } else {
5669 // Build a call to the conversion function.
John McCallb13b7372010-02-01 03:16:54 +00005670 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
John Wiegley429bb272011-04-08 18:41:53 +00005671 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), 0,
John McCall9aa472c2010-03-19 07:35:19 +00005672 FoundFn);
Richard Smith82f145d2013-05-04 06:44:46 +00005673 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5674 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005675
5676 // FIXME: Should we move this initialization into a separate
Douglas Gregor20093b42009-12-09 23:02:17 +00005677 // derived-to-base conversion? I believe the answer is "no", because
5678 // we don't want to turn off access control here for c-style casts.
John Wiegley429bb272011-04-08 18:41:53 +00005679 ExprResult CurInitExprRes =
5680 S.PerformObjectArgumentInitialization(CurInit.take(), /*Qualifier=*/0,
5681 FoundFn, Conversion);
5682 if(CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005683 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005684 CurInit = CurInitExprRes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005685
Douglas Gregor20093b42009-12-09 23:02:17 +00005686 // Build the actual call to the conversion function.
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005687 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5688 HadMultipleCandidates);
Douglas Gregor20093b42009-12-09 23:02:17 +00005689 if (CurInit.isInvalid() || !CurInit.get())
John McCallf312b1e2010-08-26 23:41:50 +00005690 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005691
John McCall2de56d12010-08-25 11:45:40 +00005692 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005693
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005694 CreatedObject = Conversion->getResultType()->isRecordType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005695 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005696
Sebastian Redl3b802322011-07-14 19:07:55 +00005697 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
Abramo Bagnara960809e2011-11-16 22:46:05 +00005698 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
5699
5700 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
John Wiegley429bb272011-04-08 18:41:53 +00005701 QualType T = CurInit.get()->getType();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005702 if (const RecordType *Record = T->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005703 CXXDestructorDecl *Destructor
Douglas Gregordb89f282010-07-01 22:47:18 +00005704 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
John Wiegley429bb272011-04-08 18:41:53 +00005705 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005706 S.PDiag(diag::err_access_dtor_temp) << T);
Eli Friedman5f2987c2012-02-02 03:46:19 +00005707 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005708 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
5709 return ExprError();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005710 }
5711 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005712
John McCallf871d0c2010-08-07 06:22:56 +00005713 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
John Wiegley429bb272011-04-08 18:41:53 +00005714 CurInit.get()->getType(),
5715 CastKind, CurInit.get(), 0,
Eli Friedman104be6f2011-09-27 01:11:35 +00005716 CurInit.get()->getValueKind()));
Abramo Bagnara960809e2011-11-16 22:46:05 +00005717 if (MaybeBindToTemp)
5718 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Douglas Gregor2f599792010-04-02 18:24:57 +00005719 if (RequiresCopy)
Douglas Gregor523d46a2010-04-18 07:40:54 +00005720 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005721 CurInit, /*IsExtraneousCopy=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00005722 break;
5723 }
Sebastian Redl906082e2010-07-20 04:20:21 +00005724
Douglas Gregor20093b42009-12-09 23:02:17 +00005725 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005726 case SK_QualificationConversionXValue:
5727 case SK_QualificationConversionRValue: {
Douglas Gregor20093b42009-12-09 23:02:17 +00005728 // Perform a qualification conversion; these can never go wrong.
John McCall5baba9d2010-08-25 10:28:54 +00005729 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005730 Step->Kind == SK_QualificationConversionLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005731 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005732 (Step->Kind == SK_QualificationConversionXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005733 VK_XValue :
5734 VK_RValue);
John Wiegley429bb272011-04-08 18:41:53 +00005735 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK);
Douglas Gregor20093b42009-12-09 23:02:17 +00005736 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00005737 }
5738
Jordan Rose1fd1e282013-04-11 00:58:58 +00005739 case SK_LValueToRValue: {
5740 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
5741 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
5742 CK_LValueToRValue,
5743 CurInit.take(),
5744 /*BasePath=*/0,
5745 VK_RValue));
5746 break;
5747 }
5748
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005749 case SK_ConversionSequence: {
John McCallf85e1932011-06-15 23:02:42 +00005750 Sema::CheckedConversionKind CCK
5751 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
5752 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
Richard Smithc8d7f582011-11-29 22:48:16 +00005753 : Kind.isExplicitCast()? Sema::CCK_OtherCast
John McCallf85e1932011-06-15 23:02:42 +00005754 : Sema::CCK_ImplicitConversion;
John Wiegley429bb272011-04-08 18:41:53 +00005755 ExprResult CurInitExprRes =
5756 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
John McCallf85e1932011-06-15 23:02:42 +00005757 getAssignmentAction(Entity), CCK);
John Wiegley429bb272011-04-08 18:41:53 +00005758 if (CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005759 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005760 CurInit = CurInitExprRes;
Douglas Gregor20093b42009-12-09 23:02:17 +00005761 break;
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005762 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005763
Douglas Gregord87b61f2009-12-10 17:56:55 +00005764 case SK_ListInitialization: {
John Wiegley429bb272011-04-08 18:41:53 +00005765 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005766 // Hack: We must pass *ResultType if available in order to set the type
5767 // of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
5768 // But in 'const X &x = {1, 2, 3};' we're supposed to initialize a
5769 // temporary, not a reference, so we should pass Ty.
5770 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
5771 // Since this step is never used for a reference directly, we explicitly
5772 // unwrap references here and rewrap them afterwards.
5773 // We also need to create a InitializeTemporary entity for this.
5774 QualType Ty = ResultType ? ResultType->getNonReferenceType() : Step->Type;
Sebastian Redlcbf82092012-03-07 16:10:45 +00005775 bool IsTemporary = Entity.getType()->isReferenceType();
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005776 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
Richard Smith802e2262013-02-02 01:13:06 +00005777 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
5778 InitListChecker PerformInitList(S, InitEntity,
Richard Smith40cba902013-06-06 11:41:05 +00005779 InitList, Ty, /*VerifyOnly=*/false);
Sebastian Redl14b0c192011-09-24 17:48:00 +00005780 if (PerformInitList.HadError())
John McCallf312b1e2010-08-26 23:41:50 +00005781 return ExprError();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005782
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005783 if (ResultType) {
5784 if ((*ResultType)->isRValueReferenceType())
5785 Ty = S.Context.getRValueReferenceType(Ty);
5786 else if ((*ResultType)->isLValueReferenceType())
5787 Ty = S.Context.getLValueReferenceType(Ty,
5788 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
5789 *ResultType = Ty;
5790 }
5791
5792 InitListExpr *StructuredInitList =
5793 PerformInitList.getFullyStructuredList();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005794 CurInit.release();
Richard Smith802e2262013-02-02 01:13:06 +00005795 CurInit = shouldBindAsTemporary(InitEntity)
5796 ? S.MaybeBindToTemporary(StructuredInitList)
5797 : S.Owned(StructuredInitList);
Douglas Gregord87b61f2009-12-10 17:56:55 +00005798 break;
5799 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00005800
Sebastian Redl10f04a62011-12-22 14:44:04 +00005801 case SK_ListConstructorCall: {
Sebastian Redl168319c2012-02-12 16:37:24 +00005802 // When an initializer list is passed for a parameter of type "reference
5803 // to object", we don't get an EK_Temporary entity, but instead an
5804 // EK_Parameter entity with reference type.
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005805 // FIXME: This is a hack. What we really should do is create a user
5806 // conversion step for this case, but this makes it considerably more
5807 // complicated. For now, this will do.
Sebastian Redl168319c2012-02-12 16:37:24 +00005808 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
5809 Entity.getType().getNonReferenceType());
5810 bool UseTemporary = Entity.getType()->isReferenceType();
Richard Smithf4bb8d02012-07-05 08:39:21 +00005811 assert(Args.size() == 1 && "expected a single argument for list init");
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005812 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Richard Smith03544fc2012-04-19 06:58:00 +00005813 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
5814 << InitList->getSourceRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005815 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
Sebastian Redl168319c2012-02-12 16:37:24 +00005816 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
5817 Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005818 Kind, Arg, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005819 ConstructorInitRequiresZeroInit,
5820 /*IsListInitialization*/ true);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005821 break;
5822 }
Sebastian Redl8713d4e2011-09-24 17:47:52 +00005823
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005824 case SK_UnwrapInitList:
5825 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0));
5826 break;
5827
5828 case SK_RewrapInitList: {
5829 Expr *E = CurInit.take();
5830 InitListExpr *Syntactic = Step->WrappingSyntacticList;
5831 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00005832 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005833 ILE->setSyntacticForm(Syntactic);
5834 ILE->setType(E->getType());
5835 ILE->setValueKind(E->getValueKind());
5836 CurInit = S.Owned(ILE);
5837 break;
5838 }
5839
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005840 case SK_ConstructorInitialization: {
5841 // When an initializer list is passed for a parameter of type "reference
5842 // to object", we don't get an EK_Temporary entity, but instead an
5843 // EK_Parameter entity with reference type.
5844 // FIXME: This is a hack. What we really should do is create a user
5845 // conversion step for this case, but this makes it considerably more
5846 // complicated. For now, this will do.
5847 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
5848 Entity.getType().getNonReferenceType());
5849 bool UseTemporary = Entity.getType()->isReferenceType();
5850 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity
5851 : Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005852 Kind, Args, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005853 ConstructorInitRequiresZeroInit,
5854 /*IsListInitialization*/ false);
Douglas Gregor51c56d62009-12-14 20:49:26 +00005855 break;
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005856 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005857
Douglas Gregor71d17402009-12-15 00:01:57 +00005858 case SK_ZeroInitialization: {
Douglas Gregor16006c92009-12-16 18:50:27 +00005859 step_iterator NextStep = Step;
5860 ++NextStep;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005861 if (NextStep != StepEnd &&
Richard Smithf4bb8d02012-07-05 08:39:21 +00005862 (NextStep->Kind == SK_ConstructorInitialization ||
5863 NextStep->Kind == SK_ListConstructorCall)) {
Douglas Gregor16006c92009-12-16 18:50:27 +00005864 // The need for zero-initialization is recorded directly into
5865 // the call to the object's constructor within the next step.
5866 ConstructorInitRequiresZeroInit = true;
5867 } else if (Kind.getKind() == InitializationKind::IK_Value &&
David Blaikie4e4d0842012-03-11 07:00:24 +00005868 S.getLangOpts().CPlusPlus &&
Douglas Gregor16006c92009-12-16 18:50:27 +00005869 !Kind.isImplicitValueInit()) {
Douglas Gregorab6677e2010-09-08 00:15:04 +00005870 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5871 if (!TSInfo)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005872 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
Douglas Gregorab6677e2010-09-08 00:15:04 +00005873 Kind.getRange().getBegin());
5874
5875 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr(
5876 TSInfo->getType().getNonLValueExprType(S.Context),
5877 TSInfo,
Douglas Gregor71d17402009-12-15 00:01:57 +00005878 Kind.getRange().getEnd()));
Douglas Gregor16006c92009-12-16 18:50:27 +00005879 } else {
Douglas Gregor71d17402009-12-15 00:01:57 +00005880 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
Douglas Gregor16006c92009-12-16 18:50:27 +00005881 }
Douglas Gregor71d17402009-12-15 00:01:57 +00005882 break;
5883 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005884
5885 case SK_CAssignment: {
John Wiegley429bb272011-04-08 18:41:53 +00005886 QualType SourceType = CurInit.get()->getType();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005887 ExprResult Result = CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005888 Sema::AssignConvertType ConvTy =
John Wiegley429bb272011-04-08 18:41:53 +00005889 S.CheckSingleAssignmentConstraints(Step->Type, Result);
5890 if (Result.isInvalid())
5891 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005892 CurInit = Result;
Douglas Gregoraa037312009-12-22 07:24:36 +00005893
5894 // If this is a call, allow conversion to a transparent union.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005895 ExprResult CurInitExprRes = CurInit;
Douglas Gregoraa037312009-12-22 07:24:36 +00005896 if (ConvTy != Sema::Compatible &&
5897 Entity.getKind() == InitializedEntity::EK_Parameter &&
John Wiegley429bb272011-04-08 18:41:53 +00005898 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
Douglas Gregoraa037312009-12-22 07:24:36 +00005899 == Sema::Compatible)
5900 ConvTy = Sema::Compatible;
John Wiegley429bb272011-04-08 18:41:53 +00005901 if (CurInitExprRes.isInvalid())
5902 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005903 CurInit = CurInitExprRes;
Douglas Gregoraa037312009-12-22 07:24:36 +00005904
Douglas Gregora41a8c52010-04-22 00:20:18 +00005905 bool Complained;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005906 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
5907 Step->Type, SourceType,
John Wiegley429bb272011-04-08 18:41:53 +00005908 CurInit.get(),
Douglas Gregora41a8c52010-04-22 00:20:18 +00005909 getAssignmentAction(Entity),
5910 &Complained)) {
5911 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005912 return ExprError();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005913 } else if (Complained)
5914 PrintInitLocationNote(S, Entity);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005915 break;
5916 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005917
5918 case SK_StringInit: {
5919 QualType Ty = Step->Type;
John Wiegley429bb272011-04-08 18:41:53 +00005920 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
John McCallfef8b342011-02-21 07:57:55 +00005921 S.Context.getAsArrayType(Ty), S);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005922 break;
5923 }
Douglas Gregor569c3162010-08-07 11:51:51 +00005924
5925 case SK_ObjCObjectConversion:
John Wiegley429bb272011-04-08 18:41:53 +00005926 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005927 CK_ObjCObjectLValueCast,
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00005928 CurInit.get()->getValueKind());
Douglas Gregor569c3162010-08-07 11:51:51 +00005929 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005930
5931 case SK_ArrayInit:
5932 // Okay: we checked everything before creating this step. Note that
5933 // this is a GNU extension.
5934 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
John Wiegley429bb272011-04-08 18:41:53 +00005935 << Step->Type << CurInit.get()->getType()
5936 << CurInit.get()->getSourceRange();
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005937
5938 // If the destination type is an incomplete array type, update the
5939 // type accordingly.
5940 if (ResultType) {
5941 if (const IncompleteArrayType *IncompleteDest
5942 = S.Context.getAsIncompleteArrayType(Step->Type)) {
5943 if (const ConstantArrayType *ConstantSource
John Wiegley429bb272011-04-08 18:41:53 +00005944 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005945 *ResultType = S.Context.getConstantArrayType(
5946 IncompleteDest->getElementType(),
5947 ConstantSource->getSize(),
5948 ArrayType::Normal, 0);
5949 }
5950 }
5951 }
John McCallf85e1932011-06-15 23:02:42 +00005952 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005953
Richard Smith0f163e92012-02-15 22:38:09 +00005954 case SK_ParenthesizedArrayInit:
5955 // Okay: we checked everything before creating this step. Note that
5956 // this is a GNU extension.
5957 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
5958 << CurInit.get()->getSourceRange();
5959 break;
5960
John McCallf85e1932011-06-15 23:02:42 +00005961 case SK_PassByIndirectCopyRestore:
5962 case SK_PassByIndirectRestore:
5963 checkIndirectCopyRestoreSource(S, CurInit.get());
5964 CurInit = S.Owned(new (S.Context)
5965 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type,
5966 Step->Kind == SK_PassByIndirectCopyRestore));
5967 break;
5968
5969 case SK_ProduceObjCObject:
5970 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
John McCall33e56f32011-09-10 06:18:15 +00005971 CK_ARCProduceObject,
John McCallf85e1932011-06-15 23:02:42 +00005972 CurInit.take(), 0, VK_RValue));
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005973 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00005974
5975 case SK_StdInitializerList: {
5976 QualType Dest = Step->Type;
5977 QualType E;
Douglas Gregor6c5aaed2013-03-25 23:47:01 +00005978 bool Success = S.isStdInitializerList(Dest.getNonReferenceType(), &E);
Sebastian Redl2b916b82012-01-17 22:49:42 +00005979 (void)Success;
5980 assert(Success && "Destination type changed?");
Sebastian Redl28357452012-03-05 19:35:43 +00005981
5982 // If the element type has a destructor, check it.
5983 if (CXXRecordDecl *RD = E->getAsCXXRecordDecl()) {
5984 if (!RD->hasIrrelevantDestructor()) {
5985 if (CXXDestructorDecl *Destructor = S.LookupDestructor(RD)) {
5986 S.MarkFunctionReferenced(Kind.getLocation(), Destructor);
5987 S.CheckDestructorAccess(Kind.getLocation(), Destructor,
5988 S.PDiag(diag::err_access_dtor_temp) << E);
Richard Smith82f145d2013-05-04 06:44:46 +00005989 if (S.DiagnoseUseOfDecl(Destructor, Kind.getLocation()))
5990 return ExprError();
Sebastian Redl28357452012-03-05 19:35:43 +00005991 }
5992 }
5993 }
5994
Sebastian Redl2b916b82012-01-17 22:49:42 +00005995 InitListExpr *ILE = cast<InitListExpr>(CurInit.take());
Richard Smith03544fc2012-04-19 06:58:00 +00005996 S.Diag(ILE->getExprLoc(), diag::warn_cxx98_compat_initializer_list_init)
5997 << ILE->getSourceRange();
Sebastian Redl2b916b82012-01-17 22:49:42 +00005998 unsigned NumInits = ILE->getNumInits();
5999 SmallVector<Expr*, 16> Converted(NumInits);
6000 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
6001 S.Context.getConstantArrayType(E,
6002 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6003 NumInits),
6004 ArrayType::Normal, 0));
6005 InitializedEntity Element =InitializedEntity::InitializeElement(S.Context,
6006 0, HiddenArray);
6007 for (unsigned i = 0; i < NumInits; ++i) {
6008 Element.setElementIndex(i);
6009 ExprResult Init = S.Owned(ILE->getInit(i));
Richard Smitha4dc51b2013-02-05 05:52:24 +00006010 ExprResult Res = S.PerformCopyInitialization(
6011 Element, Init.get()->getExprLoc(), Init,
6012 /*TopLevelOfInitList=*/ true);
Richard Smith2c2f09e2013-05-23 23:20:04 +00006013 if (Res.isInvalid())
6014 return ExprError();
Sebastian Redl2b916b82012-01-17 22:49:42 +00006015 Converted[i] = Res.take();
6016 }
6017 InitListExpr *Semantic = new (S.Context)
6018 InitListExpr(S.Context, ILE->getLBraceLoc(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00006019 Converted, ILE->getRBraceLoc());
Sebastian Redl2b916b82012-01-17 22:49:42 +00006020 Semantic->setSyntacticForm(ILE);
6021 Semantic->setType(Dest);
Sebastian Redl32cf1f22012-02-17 08:42:25 +00006022 Semantic->setInitializesStdInitializerList();
Sebastian Redl2b916b82012-01-17 22:49:42 +00006023 CurInit = S.Owned(Semantic);
6024 break;
6025 }
Guy Benyei21f18c42013-02-07 10:55:47 +00006026 case SK_OCLSamplerInit: {
6027 assert(Step->Type->isSamplerT() &&
6028 "Sampler initialization on non sampler type.");
6029
6030 QualType SourceType = CurInit.get()->getType();
6031 InitializedEntity::EntityKind EntityKind = Entity.getKind();
6032
6033 if (EntityKind == InitializedEntity::EK_Parameter) {
6034 if (!SourceType->isSamplerT())
6035 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6036 << SourceType;
6037 } else if (EntityKind != InitializedEntity::EK_Variable) {
6038 llvm_unreachable("Invalid EntityKind!");
6039 }
6040
6041 break;
6042 }
Guy Benyeie6b9d802013-01-20 12:31:11 +00006043 case SK_OCLZeroEvent: {
6044 assert(Step->Type->isEventT() &&
6045 "Event initialization on non event type.");
6046
6047 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
6048 CK_ZeroToOCLEvent,
6049 CurInit.get()->getValueKind());
6050 break;
6051 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006052 }
6053 }
John McCall15d7d122010-11-11 03:21:53 +00006054
6055 // Diagnose non-fatal problems with the completed initialization.
6056 if (Entity.getKind() == InitializedEntity::EK_Member &&
6057 cast<FieldDecl>(Entity.getDecl())->isBitField())
6058 S.CheckBitFieldInitialization(Kind.getLocation(),
6059 cast<FieldDecl>(Entity.getDecl()),
6060 CurInit.get());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006061
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006062 return CurInit;
Douglas Gregor20093b42009-12-09 23:02:17 +00006063}
6064
Richard Smithd5bc8672012-12-08 02:01:17 +00006065/// Somewhere within T there is an uninitialized reference subobject.
6066/// Dig it out and diagnose it.
Benjamin Kramera574c892013-02-15 12:30:38 +00006067static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6068 QualType T) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006069 if (T->isReferenceType()) {
6070 S.Diag(Loc, diag::err_reference_without_init)
6071 << T.getNonReferenceType();
6072 return true;
6073 }
6074
6075 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6076 if (!RD || !RD->hasUninitializedReferenceMember())
6077 return false;
6078
6079 for (CXXRecordDecl::field_iterator FI = RD->field_begin(),
6080 FE = RD->field_end(); FI != FE; ++FI) {
6081 if (FI->isUnnamedBitfield())
6082 continue;
6083
6084 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6085 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6086 return true;
6087 }
6088 }
6089
6090 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
6091 BE = RD->bases_end();
6092 BI != BE; ++BI) {
6093 if (DiagnoseUninitializedReference(S, BI->getLocStart(), BI->getType())) {
6094 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6095 return true;
6096 }
6097 }
6098
6099 return false;
6100}
6101
6102
Douglas Gregor20093b42009-12-09 23:02:17 +00006103//===----------------------------------------------------------------------===//
6104// Diagnose initialization failures
6105//===----------------------------------------------------------------------===//
John McCall7cca8212013-03-19 07:04:25 +00006106
6107/// Emit notes associated with an initialization that failed due to a
6108/// "simple" conversion failure.
6109static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6110 Expr *op) {
6111 QualType destType = entity.getType();
6112 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6113 op->getType()->isObjCObjectPointerType()) {
6114
6115 // Emit a possible note about the conversion failing because the
6116 // operand is a message send with a related result type.
6117 S.EmitRelatedResultTypeNote(op);
6118
6119 // Emit a possible note about a return failing because we're
6120 // expecting a related result type.
6121 if (entity.getKind() == InitializedEntity::EK_Result)
6122 S.EmitRelatedResultTypeNoteForReturn(destType);
6123 }
6124}
6125
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006126bool InitializationSequence::Diagnose(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00006127 const InitializedEntity &Entity,
6128 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006129 ArrayRef<Expr *> Args) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00006130 if (!Failed())
Douglas Gregor20093b42009-12-09 23:02:17 +00006131 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006132
Douglas Gregord6542d82009-12-22 15:35:07 +00006133 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00006134 switch (Failure) {
6135 case FK_TooManyInitsForReference:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006136 // FIXME: Customize for the initialized entity?
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006137 if (Args.empty()) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006138 // Dig out the reference subobject which is uninitialized and diagnose it.
6139 // If this is value-initialization, this could be nested some way within
6140 // the target type.
6141 assert(Kind.getKind() == InitializationKind::IK_Value ||
6142 DestType->isReferenceType());
6143 bool Diagnosed =
6144 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6145 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6146 (void)Diagnosed;
6147 } else // FIXME: diagnostic below could be better!
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006148 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006149 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
Douglas Gregor20093b42009-12-09 23:02:17 +00006150 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006151
Douglas Gregor20093b42009-12-09 23:02:17 +00006152 case FK_ArrayNeedsInitList:
Hans Wennborg0ff50742013-05-15 11:03:04 +00006153 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
Douglas Gregor20093b42009-12-09 23:02:17 +00006154 break;
Hans Wennborg0ff50742013-05-15 11:03:04 +00006155 case FK_ArrayNeedsInitListOrStringLiteral:
6156 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6157 break;
6158 case FK_ArrayNeedsInitListOrWideStringLiteral:
6159 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6160 break;
6161 case FK_NarrowStringIntoWideCharArray:
6162 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6163 break;
6164 case FK_WideStringIntoCharArray:
6165 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6166 break;
6167 case FK_IncompatWideStringIntoWideChar:
6168 S.Diag(Kind.getLocation(),
6169 diag::err_array_init_incompat_wide_string_into_wchar);
6170 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006171 case FK_ArrayTypeMismatch:
6172 case FK_NonConstantArrayInit:
6173 S.Diag(Kind.getLocation(),
6174 (Failure == FK_ArrayTypeMismatch
6175 ? diag::err_array_init_different_type
6176 : diag::err_array_init_non_constant_array))
6177 << DestType.getNonReferenceType()
6178 << Args[0]->getType()
6179 << Args[0]->getSourceRange();
6180 break;
6181
John McCall73076432012-01-05 00:13:19 +00006182 case FK_VariableLengthArrayHasInitializer:
6183 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6184 << Args[0]->getSourceRange();
6185 break;
6186
John McCall6bb80172010-03-30 21:47:33 +00006187 case FK_AddressOfOverloadFailed: {
6188 DeclAccessPair Found;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006189 S.ResolveAddressOfOverloadedFunction(Args[0],
Douglas Gregor20093b42009-12-09 23:02:17 +00006190 DestType.getNonReferenceType(),
John McCall6bb80172010-03-30 21:47:33 +00006191 true,
6192 Found);
Douglas Gregor20093b42009-12-09 23:02:17 +00006193 break;
John McCall6bb80172010-03-30 21:47:33 +00006194 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006195
Douglas Gregor20093b42009-12-09 23:02:17 +00006196 case FK_ReferenceInitOverloadFailed:
Douglas Gregor4a520a22009-12-14 17:27:33 +00006197 case FK_UserConversionOverloadFailed:
Douglas Gregor20093b42009-12-09 23:02:17 +00006198 switch (FailedOverloadResult) {
6199 case OR_Ambiguous:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006200 if (Failure == FK_UserConversionOverloadFailed)
6201 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6202 << Args[0]->getType() << DestType
6203 << Args[0]->getSourceRange();
6204 else
6205 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6206 << DestType << Args[0]->getType()
6207 << Args[0]->getSourceRange();
6208
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006209 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006210 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006211
Douglas Gregor20093b42009-12-09 23:02:17 +00006212 case OR_No_Viable_Function:
6213 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6214 << Args[0]->getType() << DestType.getNonReferenceType()
6215 << Args[0]->getSourceRange();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006216 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006217 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006218
Douglas Gregor20093b42009-12-09 23:02:17 +00006219 case OR_Deleted: {
6220 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6221 << Args[0]->getType() << DestType.getNonReferenceType()
6222 << Args[0]->getSourceRange();
6223 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006224 OverloadingResult Ovl
Douglas Gregor8fcc5162010-09-12 08:07:23 +00006225 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6226 true);
Douglas Gregor20093b42009-12-09 23:02:17 +00006227 if (Ovl == OR_Deleted) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00006228 S.NoteDeletedFunction(Best->Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00006229 } else {
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006230 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregor20093b42009-12-09 23:02:17 +00006231 }
6232 break;
6233 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006234
Douglas Gregor20093b42009-12-09 23:02:17 +00006235 case OR_Success:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006236 llvm_unreachable("Conversion did not fail!");
Douglas Gregor20093b42009-12-09 23:02:17 +00006237 }
6238 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006239
Douglas Gregor20093b42009-12-09 23:02:17 +00006240 case FK_NonConstLValueReferenceBindingToTemporary:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006241 if (isa<InitListExpr>(Args[0])) {
6242 S.Diag(Kind.getLocation(),
6243 diag::err_lvalue_reference_bind_to_initlist)
6244 << DestType.getNonReferenceType().isVolatileQualified()
6245 << DestType.getNonReferenceType()
6246 << Args[0]->getSourceRange();
6247 break;
6248 }
6249 // Intentional fallthrough
6250
Douglas Gregor20093b42009-12-09 23:02:17 +00006251 case FK_NonConstLValueReferenceBindingToUnrelated:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006252 S.Diag(Kind.getLocation(),
Douglas Gregor20093b42009-12-09 23:02:17 +00006253 Failure == FK_NonConstLValueReferenceBindingToTemporary
6254 ? diag::err_lvalue_reference_bind_to_temporary
6255 : diag::err_lvalue_reference_bind_to_unrelated)
Douglas Gregoref06e242010-01-29 19:39:15 +00006256 << DestType.getNonReferenceType().isVolatileQualified()
Douglas Gregor20093b42009-12-09 23:02:17 +00006257 << DestType.getNonReferenceType()
6258 << Args[0]->getType()
6259 << Args[0]->getSourceRange();
6260 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006261
Douglas Gregor20093b42009-12-09 23:02:17 +00006262 case FK_RValueReferenceBindingToLValue:
6263 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
Douglas Gregorfb5d7ef2011-01-21 01:04:33 +00006264 << DestType.getNonReferenceType() << Args[0]->getType()
Douglas Gregor20093b42009-12-09 23:02:17 +00006265 << Args[0]->getSourceRange();
6266 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006267
Douglas Gregor20093b42009-12-09 23:02:17 +00006268 case FK_ReferenceInitDropsQualifiers:
6269 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
6270 << DestType.getNonReferenceType()
6271 << Args[0]->getType()
6272 << Args[0]->getSourceRange();
6273 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006274
Douglas Gregor20093b42009-12-09 23:02:17 +00006275 case FK_ReferenceInitFailed:
6276 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
6277 << DestType.getNonReferenceType()
John McCall7eb0a9e2010-11-24 05:12:34 +00006278 << Args[0]->isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00006279 << Args[0]->getType()
6280 << Args[0]->getSourceRange();
John McCall7cca8212013-03-19 07:04:25 +00006281 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00006282 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006283
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006284 case FK_ConversionFailed: {
6285 QualType FromType = Args[0]->getType();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006286 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006287 << (int)Entity.getKind()
Douglas Gregor20093b42009-12-09 23:02:17 +00006288 << DestType
John McCall7eb0a9e2010-11-24 05:12:34 +00006289 << Args[0]->isLValue()
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006290 << FromType
Douglas Gregor20093b42009-12-09 23:02:17 +00006291 << Args[0]->getSourceRange();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006292 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
6293 S.Diag(Kind.getLocation(), PDiag);
John McCall7cca8212013-03-19 07:04:25 +00006294 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregord87b61f2009-12-10 17:56:55 +00006295 break;
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006296 }
John Wiegley429bb272011-04-08 18:41:53 +00006297
6298 case FK_ConversionFromPropertyFailed:
6299 // No-op. This error has already been reported.
6300 break;
6301
Douglas Gregord87b61f2009-12-10 17:56:55 +00006302 case FK_TooManyInitsForScalar: {
Douglas Gregor99a2e602009-12-16 01:38:02 +00006303 SourceRange R;
6304
6305 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
Douglas Gregor19311e72010-09-08 21:40:08 +00006306 R = SourceRange(InitList->getInit(0)->getLocEnd(),
Douglas Gregor99a2e602009-12-16 01:38:02 +00006307 InitList->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006308 else
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006309 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
Douglas Gregord87b61f2009-12-10 17:56:55 +00006310
Douglas Gregor19311e72010-09-08 21:40:08 +00006311 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin()));
6312 if (Kind.isCStyleOrFunctionalCast())
6313 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
6314 << R;
6315 else
6316 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
6317 << /*scalar=*/2 << R;
Douglas Gregord87b61f2009-12-10 17:56:55 +00006318 break;
6319 }
6320
6321 case FK_ReferenceBindingToInitList:
6322 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
6323 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
6324 break;
6325
6326 case FK_InitListBadDestinationType:
6327 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
6328 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
6329 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006330
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006331 case FK_ListConstructorOverloadFailed:
Douglas Gregor51c56d62009-12-14 20:49:26 +00006332 case FK_ConstructorOverloadFailed: {
6333 SourceRange ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006334 if (Args.size())
6335 ArgsRange = SourceRange(Args.front()->getLocStart(),
6336 Args.back()->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006337
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006338 if (Failure == FK_ListConstructorOverloadFailed) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006339 assert(Args.size() == 1 && "List construction from other than 1 argument.");
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006340 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006341 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006342 }
6343
Douglas Gregor51c56d62009-12-14 20:49:26 +00006344 // FIXME: Using "DestType" for the entity we're printing is probably
6345 // bad.
6346 switch (FailedOverloadResult) {
6347 case OR_Ambiguous:
6348 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
6349 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006350 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006351 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006352
Douglas Gregor51c56d62009-12-14 20:49:26 +00006353 case OR_No_Viable_Function:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006354 if (Kind.getKind() == InitializationKind::IK_Default &&
6355 (Entity.getKind() == InitializedEntity::EK_Base ||
6356 Entity.getKind() == InitializedEntity::EK_Member) &&
6357 isa<CXXConstructorDecl>(S.CurContext)) {
6358 // This is implicit default initialization of a member or
6359 // base within a constructor. If no viable function was
6360 // found, notify the user that she needs to explicitly
6361 // initialize this base/member.
6362 CXXConstructorDecl *Constructor
6363 = cast<CXXConstructorDecl>(S.CurContext);
6364 if (Entity.getKind() == InitializedEntity::EK_Base) {
6365 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006366 << (Constructor->getInheritedConstructor() ? 2 :
6367 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006368 << S.Context.getTypeDeclType(Constructor->getParent())
6369 << /*base=*/0
6370 << Entity.getType();
6371
6372 RecordDecl *BaseDecl
6373 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
6374 ->getDecl();
6375 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
6376 << S.Context.getTagDeclType(BaseDecl);
6377 } else {
6378 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006379 << (Constructor->getInheritedConstructor() ? 2 :
6380 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006381 << S.Context.getTypeDeclType(Constructor->getParent())
6382 << /*member=*/1
6383 << Entity.getName();
6384 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
6385
6386 if (const RecordType *Record
6387 = Entity.getType()->getAs<RecordType>())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006388 S.Diag(Record->getDecl()->getLocation(),
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006389 diag::note_previous_decl)
6390 << S.Context.getTagDeclType(Record->getDecl());
6391 }
6392 break;
6393 }
6394
Douglas Gregor51c56d62009-12-14 20:49:26 +00006395 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
6396 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006397 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006398 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006399
Douglas Gregor51c56d62009-12-14 20:49:26 +00006400 case OR_Deleted: {
Douglas Gregor51c56d62009-12-14 20:49:26 +00006401 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006402 OverloadingResult Ovl
6403 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Douglas Gregore4e68d42012-02-15 19:33:52 +00006404 if (Ovl != OR_Deleted) {
6405 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6406 << true << DestType << ArgsRange;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006407 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregore4e68d42012-02-15 19:33:52 +00006408 break;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006409 }
Douglas Gregore4e68d42012-02-15 19:33:52 +00006410
6411 // If this is a defaulted or implicitly-declared function, then
6412 // it was implicitly deleted. Make it clear that the deletion was
6413 // implicit.
Richard Smith6c4c36c2012-03-30 20:53:28 +00006414 if (S.isImplicitlyDeleted(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006415 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
Richard Smith6c4c36c2012-03-30 20:53:28 +00006416 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006417 << DestType << ArgsRange;
Richard Smith6c4c36c2012-03-30 20:53:28 +00006418 else
6419 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6420 << true << DestType << ArgsRange;
6421
6422 S.NoteDeletedFunction(Best->Function);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006423 break;
6424 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006425
Douglas Gregor51c56d62009-12-14 20:49:26 +00006426 case OR_Success:
6427 llvm_unreachable("Conversion did not fail!");
Douglas Gregor51c56d62009-12-14 20:49:26 +00006428 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00006429 }
David Blaikie9fdefb32012-01-17 08:24:58 +00006430 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006431
Douglas Gregor99a2e602009-12-16 01:38:02 +00006432 case FK_DefaultInitOfConst:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006433 if (Entity.getKind() == InitializedEntity::EK_Member &&
6434 isa<CXXConstructorDecl>(S.CurContext)) {
6435 // This is implicit default-initialization of a const member in
6436 // a constructor. Complain that it needs to be explicitly
6437 // initialized.
6438 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
6439 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006440 << (Constructor->getInheritedConstructor() ? 2 :
6441 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006442 << S.Context.getTypeDeclType(Constructor->getParent())
6443 << /*const=*/1
6444 << Entity.getName();
6445 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
6446 << Entity.getName();
6447 } else {
6448 S.Diag(Kind.getLocation(), diag::err_default_init_const)
6449 << DestType << (bool)DestType->getAs<RecordType>();
6450 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00006451 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006452
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006453 case FK_Incomplete:
Douglas Gregor69a30b82012-04-10 20:43:46 +00006454 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006455 diag::err_init_incomplete_type);
6456 break;
6457
Sebastian Redl14b0c192011-09-24 17:48:00 +00006458 case FK_ListInitializationFailed: {
6459 // Run the init list checker again to emit diagnostics.
6460 InitListExpr* InitList = cast<InitListExpr>(Args[0]);
6461 QualType DestType = Entity.getType();
6462 InitListChecker DiagnoseInitList(S, Entity, InitList,
Richard Smith40cba902013-06-06 11:41:05 +00006463 DestType, /*VerifyOnly=*/false);
Sebastian Redl14b0c192011-09-24 17:48:00 +00006464 assert(DiagnoseInitList.HadError() &&
6465 "Inconsistent init list check result.");
6466 break;
6467 }
John McCall5acb0c92011-10-17 18:40:02 +00006468
6469 case FK_PlaceholderType: {
6470 // FIXME: Already diagnosed!
6471 break;
6472 }
Sebastian Redl2b916b82012-01-17 22:49:42 +00006473
6474 case FK_InitListElementCopyFailure: {
6475 // Try to perform all copies again.
6476 InitListExpr* InitList = cast<InitListExpr>(Args[0]);
6477 unsigned NumInits = InitList->getNumInits();
6478 QualType DestType = Entity.getType();
6479 QualType E;
Douglas Gregor6c5aaed2013-03-25 23:47:01 +00006480 bool Success = S.isStdInitializerList(DestType.getNonReferenceType(), &E);
Sebastian Redl2b916b82012-01-17 22:49:42 +00006481 (void)Success;
6482 assert(Success && "Where did the std::initializer_list go?");
6483 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
6484 S.Context.getConstantArrayType(E,
6485 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6486 NumInits),
6487 ArrayType::Normal, 0));
6488 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context,
6489 0, HiddenArray);
6490 // Show at most 3 errors. Otherwise, you'd get a lot of errors for errors
6491 // where the init list type is wrong, e.g.
6492 // std::initializer_list<void*> list = { 1, 2, 3, 4, 5, 6, 7, 8 };
6493 // FIXME: Emit a note if we hit the limit?
6494 int ErrorCount = 0;
6495 for (unsigned i = 0; i < NumInits && ErrorCount < 3; ++i) {
6496 Element.setElementIndex(i);
6497 ExprResult Init = S.Owned(InitList->getInit(i));
6498 if (S.PerformCopyInitialization(Element, Init.get()->getExprLoc(), Init)
6499 .isInvalid())
6500 ++ErrorCount;
6501 }
6502 break;
6503 }
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006504
6505 case FK_ExplicitConstructor: {
6506 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
6507 << Args[0]->getSourceRange();
6508 OverloadCandidateSet::iterator Best;
6509 OverloadingResult Ovl
6510 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Matt Beaumont-Gaye7d0bbf2012-04-02 19:05:35 +00006511 (void)Ovl;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006512 assert(Ovl == OR_Success && "Inconsistent overload resolution");
6513 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
6514 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
6515 break;
6516 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006517 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006518
Douglas Gregora41a8c52010-04-22 00:20:18 +00006519 PrintInitLocationNote(S, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00006520 return true;
6521}
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006522
Chris Lattner5f9e2722011-07-23 10:55:15 +00006523void InitializationSequence::dump(raw_ostream &OS) const {
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006524 switch (SequenceKind) {
6525 case FailedSequence: {
6526 OS << "Failed sequence: ";
6527 switch (Failure) {
6528 case FK_TooManyInitsForReference:
6529 OS << "too many initializers for reference";
6530 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006531
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006532 case FK_ArrayNeedsInitList:
6533 OS << "array requires initializer list";
6534 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006535
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006536 case FK_ArrayNeedsInitListOrStringLiteral:
6537 OS << "array requires initializer list or string literal";
6538 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006539
Hans Wennborg0ff50742013-05-15 11:03:04 +00006540 case FK_ArrayNeedsInitListOrWideStringLiteral:
6541 OS << "array requires initializer list or wide string literal";
6542 break;
6543
6544 case FK_NarrowStringIntoWideCharArray:
6545 OS << "narrow string into wide char array";
6546 break;
6547
6548 case FK_WideStringIntoCharArray:
6549 OS << "wide string into char array";
6550 break;
6551
6552 case FK_IncompatWideStringIntoWideChar:
6553 OS << "incompatible wide string into wide char array";
6554 break;
6555
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006556 case FK_ArrayTypeMismatch:
6557 OS << "array type mismatch";
6558 break;
6559
6560 case FK_NonConstantArrayInit:
6561 OS << "non-constant array initializer";
6562 break;
6563
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006564 case FK_AddressOfOverloadFailed:
6565 OS << "address of overloaded function failed";
6566 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006567
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006568 case FK_ReferenceInitOverloadFailed:
6569 OS << "overload resolution for reference initialization failed";
6570 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006571
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006572 case FK_NonConstLValueReferenceBindingToTemporary:
6573 OS << "non-const lvalue reference bound to temporary";
6574 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006575
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006576 case FK_NonConstLValueReferenceBindingToUnrelated:
6577 OS << "non-const lvalue reference bound to unrelated type";
6578 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006579
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006580 case FK_RValueReferenceBindingToLValue:
6581 OS << "rvalue reference bound to an lvalue";
6582 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006583
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006584 case FK_ReferenceInitDropsQualifiers:
6585 OS << "reference initialization drops qualifiers";
6586 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006587
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006588 case FK_ReferenceInitFailed:
6589 OS << "reference initialization failed";
6590 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006591
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006592 case FK_ConversionFailed:
6593 OS << "conversion failed";
6594 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006595
John Wiegley429bb272011-04-08 18:41:53 +00006596 case FK_ConversionFromPropertyFailed:
6597 OS << "conversion from property failed";
6598 break;
6599
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006600 case FK_TooManyInitsForScalar:
6601 OS << "too many initializers for scalar";
6602 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006603
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006604 case FK_ReferenceBindingToInitList:
6605 OS << "referencing binding to initializer list";
6606 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006607
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006608 case FK_InitListBadDestinationType:
6609 OS << "initializer list for non-aggregate, non-scalar type";
6610 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006611
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006612 case FK_UserConversionOverloadFailed:
6613 OS << "overloading failed for user-defined conversion";
6614 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006615
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006616 case FK_ConstructorOverloadFailed:
6617 OS << "constructor overloading failed";
6618 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006619
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006620 case FK_DefaultInitOfConst:
6621 OS << "default initialization of a const variable";
6622 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006623
Douglas Gregor72a43bb2010-05-20 22:12:02 +00006624 case FK_Incomplete:
6625 OS << "initialization of incomplete type";
6626 break;
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006627
6628 case FK_ListInitializationFailed:
Sebastian Redl14b0c192011-09-24 17:48:00 +00006629 OS << "list initialization checker failure";
John McCall5acb0c92011-10-17 18:40:02 +00006630 break;
6631
John McCall73076432012-01-05 00:13:19 +00006632 case FK_VariableLengthArrayHasInitializer:
6633 OS << "variable length array has an initializer";
6634 break;
6635
John McCall5acb0c92011-10-17 18:40:02 +00006636 case FK_PlaceholderType:
6637 OS << "initializer expression isn't contextually valid";
6638 break;
Nick Lewyckyb0c6c332011-12-22 20:21:32 +00006639
6640 case FK_ListConstructorOverloadFailed:
6641 OS << "list constructor overloading failed";
6642 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006643
6644 case FK_InitListElementCopyFailure:
6645 OS << "copy construction of initializer list element failed";
6646 break;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006647
6648 case FK_ExplicitConstructor:
6649 OS << "list copy initialization chose explicit constructor";
6650 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006651 }
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006652 OS << '\n';
6653 return;
6654 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006655
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006656 case DependentSequence:
Sebastian Redl7491c492011-06-05 13:59:11 +00006657 OS << "Dependent sequence\n";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006658 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006659
Sebastian Redl7491c492011-06-05 13:59:11 +00006660 case NormalSequence:
6661 OS << "Normal sequence: ";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006662 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006663 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006664
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006665 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6666 if (S != step_begin()) {
6667 OS << " -> ";
6668 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006669
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006670 switch (S->Kind) {
6671 case SK_ResolveAddressOfOverloadedFunction:
6672 OS << "resolve address of overloaded function";
6673 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006674
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006675 case SK_CastDerivedToBaseRValue:
6676 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6677 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006678
Sebastian Redl906082e2010-07-20 04:20:21 +00006679 case SK_CastDerivedToBaseXValue:
6680 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
6681 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006682
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006683 case SK_CastDerivedToBaseLValue:
6684 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
6685 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006686
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006687 case SK_BindReference:
6688 OS << "bind reference to lvalue";
6689 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006690
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006691 case SK_BindReferenceToTemporary:
6692 OS << "bind reference to a temporary";
6693 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006694
Douglas Gregor523d46a2010-04-18 07:40:54 +00006695 case SK_ExtraneousCopyToTemporary:
6696 OS << "extraneous C++03 copy to temporary";
6697 break;
6698
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006699 case SK_UserConversion:
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006700 OS << "user-defined conversion via " << *S->Function.Function;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006701 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006702
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006703 case SK_QualificationConversionRValue:
6704 OS << "qualification conversion (rvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006705 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006706
Sebastian Redl906082e2010-07-20 04:20:21 +00006707 case SK_QualificationConversionXValue:
6708 OS << "qualification conversion (xvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006709 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006710
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006711 case SK_QualificationConversionLValue:
6712 OS << "qualification conversion (lvalue)";
6713 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006714
Jordan Rose1fd1e282013-04-11 00:58:58 +00006715 case SK_LValueToRValue:
6716 OS << "load (lvalue to rvalue)";
6717 break;
6718
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006719 case SK_ConversionSequence:
6720 OS << "implicit conversion sequence (";
6721 S->ICS->DebugPrint(); // FIXME: use OS
6722 OS << ")";
6723 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006724
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006725 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006726 OS << "list aggregate initialization";
6727 break;
6728
6729 case SK_ListConstructorCall:
6730 OS << "list initialization via constructor";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006731 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006732
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006733 case SK_UnwrapInitList:
6734 OS << "unwrap reference initializer list";
6735 break;
6736
6737 case SK_RewrapInitList:
6738 OS << "rewrap reference initializer list";
6739 break;
6740
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006741 case SK_ConstructorInitialization:
6742 OS << "constructor initialization";
6743 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006744
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006745 case SK_ZeroInitialization:
6746 OS << "zero initialization";
6747 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006748
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006749 case SK_CAssignment:
6750 OS << "C assignment";
6751 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006752
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006753 case SK_StringInit:
6754 OS << "string initialization";
6755 break;
Douglas Gregor569c3162010-08-07 11:51:51 +00006756
6757 case SK_ObjCObjectConversion:
6758 OS << "Objective-C object conversion";
6759 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006760
6761 case SK_ArrayInit:
6762 OS << "array initialization";
6763 break;
John McCallf85e1932011-06-15 23:02:42 +00006764
Richard Smith0f163e92012-02-15 22:38:09 +00006765 case SK_ParenthesizedArrayInit:
6766 OS << "parenthesized array initialization";
6767 break;
6768
John McCallf85e1932011-06-15 23:02:42 +00006769 case SK_PassByIndirectCopyRestore:
6770 OS << "pass by indirect copy and restore";
6771 break;
6772
6773 case SK_PassByIndirectRestore:
6774 OS << "pass by indirect restore";
6775 break;
6776
6777 case SK_ProduceObjCObject:
6778 OS << "Objective-C object retension";
6779 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006780
6781 case SK_StdInitializerList:
6782 OS << "std::initializer_list from initializer list";
6783 break;
Guy Benyeie6b9d802013-01-20 12:31:11 +00006784
Guy Benyei21f18c42013-02-07 10:55:47 +00006785 case SK_OCLSamplerInit:
6786 OS << "OpenCL sampler_t from integer constant";
6787 break;
6788
Guy Benyeie6b9d802013-01-20 12:31:11 +00006789 case SK_OCLZeroEvent:
6790 OS << "OpenCL event_t from zero";
6791 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006792 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006793
6794 OS << " [" << S->Type.getAsString() << ']';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006795 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006796
6797 OS << '\n';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006798}
6799
6800void InitializationSequence::dump() const {
6801 dump(llvm::errs());
6802}
6803
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006804static void DiagnoseNarrowingInInitList(Sema &S, InitializationSequence &Seq,
6805 QualType EntityType,
6806 const Expr *PreInit,
6807 const Expr *PostInit) {
6808 if (Seq.step_begin() == Seq.step_end() || PreInit->isValueDependent())
6809 return;
6810
6811 // A narrowing conversion can only appear as the final implicit conversion in
6812 // an initialization sequence.
6813 const InitializationSequence::Step &LastStep = Seq.step_end()[-1];
6814 if (LastStep.Kind != InitializationSequence::SK_ConversionSequence)
6815 return;
6816
6817 const ImplicitConversionSequence &ICS = *LastStep.ICS;
6818 const StandardConversionSequence *SCS = 0;
6819 switch (ICS.getKind()) {
6820 case ImplicitConversionSequence::StandardConversion:
6821 SCS = &ICS.Standard;
6822 break;
6823 case ImplicitConversionSequence::UserDefinedConversion:
6824 SCS = &ICS.UserDefined.After;
6825 break;
6826 case ImplicitConversionSequence::AmbiguousConversion:
6827 case ImplicitConversionSequence::EllipsisConversion:
6828 case ImplicitConversionSequence::BadConversion:
6829 return;
6830 }
6831
6832 // Determine the type prior to the narrowing conversion. If a conversion
6833 // operator was used, this may be different from both the type of the entity
6834 // and of the pre-initialization expression.
6835 QualType PreNarrowingType = PreInit->getType();
6836 if (Seq.step_begin() + 1 != Seq.step_end())
6837 PreNarrowingType = Seq.step_end()[-2].Type;
6838
6839 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
6840 APValue ConstantValue;
Richard Smithf6028062012-03-23 23:55:39 +00006841 QualType ConstantType;
6842 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
6843 ConstantType)) {
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006844 case NK_Not_Narrowing:
6845 // No narrowing occurred.
6846 return;
6847
6848 case NK_Type_Narrowing:
6849 // This was a floating-to-integer conversion, which is always considered a
6850 // narrowing conversion even if the value is a constant and can be
6851 // represented exactly as an integer.
6852 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006853 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006854 diag::warn_init_list_type_narrowing
6855 : S.isSFINAEContext()?
6856 diag::err_init_list_type_narrowing_sfinae
6857 : diag::err_init_list_type_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006858 << PostInit->getSourceRange()
6859 << PreNarrowingType.getLocalUnqualifiedType()
6860 << EntityType.getLocalUnqualifiedType();
6861 break;
6862
6863 case NK_Constant_Narrowing:
6864 // A constant value was narrowed.
6865 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006866 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006867 diag::warn_init_list_constant_narrowing
6868 : S.isSFINAEContext()?
6869 diag::err_init_list_constant_narrowing_sfinae
6870 : diag::err_init_list_constant_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006871 << PostInit->getSourceRange()
Richard Smithf6028062012-03-23 23:55:39 +00006872 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
Jeffrey Yasskin99061492011-08-29 15:59:37 +00006873 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006874 break;
6875
6876 case NK_Variable_Narrowing:
6877 // A variable's value may have been narrowed.
6878 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006879 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006880 diag::warn_init_list_variable_narrowing
6881 : S.isSFINAEContext()?
6882 diag::err_init_list_variable_narrowing_sfinae
6883 : diag::err_init_list_variable_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006884 << PostInit->getSourceRange()
6885 << PreNarrowingType.getLocalUnqualifiedType()
Jeffrey Yasskin99061492011-08-29 15:59:37 +00006886 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006887 break;
6888 }
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006889
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00006890 SmallString<128> StaticCast;
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006891 llvm::raw_svector_ostream OS(StaticCast);
6892 OS << "static_cast<";
6893 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
6894 // It's important to use the typedef's name if there is one so that the
6895 // fixit doesn't break code using types like int64_t.
6896 //
6897 // FIXME: This will break if the typedef requires qualification. But
6898 // getQualifiedNameAsString() includes non-machine-parsable components.
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006899 OS << *TT->getDecl();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006900 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
David Blaikie4e4d0842012-03-11 07:00:24 +00006901 OS << BT->getName(S.getLangOpts());
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006902 else {
6903 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
6904 // with a broken cast.
6905 return;
6906 }
6907 OS << ">(";
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006908 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override)
6909 << PostInit->getSourceRange()
6910 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006911 << FixItHint::CreateInsertion(
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006912 S.getPreprocessor().getLocForEndOfToken(PostInit->getLocEnd()), ")");
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006913}
6914
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006915//===----------------------------------------------------------------------===//
6916// Initialization helper functions
6917//===----------------------------------------------------------------------===//
Sean Hunt2be7e902011-05-12 22:46:29 +00006918bool
6919Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
6920 ExprResult Init) {
6921 if (Init.isInvalid())
6922 return false;
6923
6924 Expr *InitE = Init.get();
6925 assert(InitE && "No initialization expression");
6926
Douglas Gregor3c394c52012-07-31 22:15:04 +00006927 InitializationKind Kind
6928 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006929 InitializationSequence Seq(*this, Entity, Kind, InitE);
Sebastian Redl383616c2011-06-05 12:23:28 +00006930 return !Seq.Failed();
Sean Hunt2be7e902011-05-12 22:46:29 +00006931}
6932
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006933ExprResult
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006934Sema::PerformCopyInitialization(const InitializedEntity &Entity,
6935 SourceLocation EqualLoc,
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006936 ExprResult Init,
Douglas Gregored878af2012-02-24 23:56:31 +00006937 bool TopLevelOfInitList,
6938 bool AllowExplicit) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006939 if (Init.isInvalid())
6940 return ExprError();
6941
John McCall15d7d122010-11-11 03:21:53 +00006942 Expr *InitE = Init.get();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006943 assert(InitE && "No initialization expression?");
6944
6945 if (EqualLoc.isInvalid())
6946 EqualLoc = InitE->getLocStart();
6947
6948 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
Douglas Gregored878af2012-02-24 23:56:31 +00006949 EqualLoc,
6950 AllowExplicit);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006951 InitializationSequence Seq(*this, Entity, Kind, InitE);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006952 Init.release();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006953
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006954 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006955
6956 if (!Result.isInvalid() && TopLevelOfInitList)
6957 DiagnoseNarrowingInInitList(*this, Seq, Entity.getType(),
6958 InitE, Result.get());
6959
6960 return Result;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006961}