blob: 26bb6efb8e05779b485c329dc76be7033d4aab0c [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
John McCallce6c9b72011-02-21 07:22:22 +000035static Expr *IsStringInit(Expr *Init, const ArrayType *AT,
36 ASTContext &Context) {
Eli Friedman8718a6a2009-05-29 18:22:49 +000037 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
38 return 0;
39
Chris Lattner8879e3b2009-02-26 23:26:43 +000040 // See if this is a string literal or @encode.
41 Init = Init->IgnoreParens();
Mike Stump1eb44332009-09-09 15:08:12 +000042
Chris Lattner8879e3b2009-02-26 23:26:43 +000043 // Handle @encode, which is a narrow string.
44 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
45 return Init;
46
47 // Otherwise we can only handle string literals.
48 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
Chris Lattner220b6362009-02-26 23:42:47 +000049 if (SL == 0) return 0;
Eli Friedmanbb6415c2009-05-31 10:54:53 +000050
51 QualType ElemTy = Context.getCanonicalType(AT->getElementType());
Douglas Gregor5cee1192011-07-27 05:40:30 +000052
53 switch (SL->getKind()) {
54 case StringLiteral::Ascii:
55 case StringLiteral::UTF8:
56 // char array can be initialized with a narrow string.
57 // Only allow char x[] = "foo"; not char x[] = L"foo";
Eli Friedmanbb6415c2009-05-31 10:54:53 +000058 return ElemTy->isCharType() ? Init : 0;
Douglas Gregor5cee1192011-07-27 05:40:30 +000059 case StringLiteral::UTF16:
60 return ElemTy->isChar16Type() ? Init : 0;
61 case StringLiteral::UTF32:
62 return ElemTy->isChar32Type() ? Init : 0;
63 case StringLiteral::Wide:
64 // wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with
65 // correction from DR343): "An array with element type compatible with a
66 // qualified or unqualified version of wchar_t may be initialized by a wide
67 // string literal, optionally enclosed in braces."
68 if (Context.typesAreCompatible(Context.getWCharType(),
69 ElemTy.getUnqualifiedType()))
70 return Init;
Chris Lattner8879e3b2009-02-26 23:26:43 +000071
Douglas Gregor5cee1192011-07-27 05:40:30 +000072 return 0;
73 }
Mike Stump1eb44332009-09-09 15:08:12 +000074
Douglas Gregor5cee1192011-07-27 05:40:30 +000075 llvm_unreachable("missed a StringLiteral kind?");
Chris Lattnerdd8e0062009-02-24 22:27:37 +000076}
77
John McCallce6c9b72011-02-21 07:22:22 +000078static Expr *IsStringInit(Expr *init, QualType declType, ASTContext &Context) {
79 const ArrayType *arrayType = Context.getAsArrayType(declType);
80 if (!arrayType) return 0;
81
82 return IsStringInit(init, arrayType, Context);
83}
84
John McCallfef8b342011-02-21 07:57:55 +000085static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
86 Sema &S) {
Chris Lattner79e079d2009-02-24 23:10:27 +000087 // Get the length of the string as parsed.
88 uint64_t StrLength =
89 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
90
Mike Stump1eb44332009-09-09 15:08:12 +000091
Chris Lattnerdd8e0062009-02-24 22:27:37 +000092 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Mike Stump1eb44332009-09-09 15:08:12 +000093 // C99 6.7.8p14. We have an array of character type with unknown size
Chris Lattnerdd8e0062009-02-24 22:27:37 +000094 // being initialized to a string literal.
Benjamin Kramer65263b42012-08-04 17:00:46 +000095 llvm::APInt ConstVal(32, StrLength);
Chris Lattnerdd8e0062009-02-24 22:27:37 +000096 // Return a new array type (C99 6.7.8p22).
John McCall46a617a2009-10-16 00:14:28 +000097 DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
98 ConstVal,
99 ArrayType::Normal, 0);
Chris Lattner19da8cd2009-02-24 23:01:39 +0000100 return;
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000101 }
Mike Stump1eb44332009-09-09 15:08:12 +0000102
Eli Friedman8718a6a2009-05-29 18:22:49 +0000103 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Mike Stump1eb44332009-09-09 15:08:12 +0000104
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000105 // We have an array of character type with known size. However,
Eli Friedman8718a6a2009-05-29 18:22:49 +0000106 // the size may be smaller or larger than the string we are initializing.
107 // FIXME: Avoid truncation for 64-bit length strings.
David Blaikie4e4d0842012-03-11 07:00:24 +0000108 if (S.getLangOpts().CPlusPlus) {
Anders Carlssonb8fc45f2011-04-14 00:41:11 +0000109 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str)) {
110 // For Pascal strings it's OK to strip off the terminating null character,
111 // so the example below is valid:
112 //
113 // unsigned char a[2] = "\pa";
114 if (SL->isPascal())
115 StrLength--;
116 }
117
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000118 // [dcl.init.string]p2
119 if (StrLength > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000120 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000121 diag::err_initializer_string_for_char_array_too_long)
122 << Str->getSourceRange();
123 } else {
124 // C99 6.7.8p14.
125 if (StrLength-1 > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000126 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000127 diag::warn_initializer_string_for_char_array_too_long)
128 << Str->getSourceRange();
129 }
Mike Stump1eb44332009-09-09 15:08:12 +0000130
Eli Friedman8718a6a2009-05-29 18:22:49 +0000131 // Set the type to the actual size that we are initializing. If we have
132 // something like:
133 // char x[1] = "foo";
134 // then this will set the string literal's type to char[1].
135 Str->setType(DeclT);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000136}
137
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000138//===----------------------------------------------------------------------===//
139// Semantic checking for initializer lists.
140//===----------------------------------------------------------------------===//
141
Douglas Gregor9e80f722009-01-29 01:05:33 +0000142/// @brief Semantic checking for initializer lists.
143///
144/// The InitListChecker class contains a set of routines that each
145/// handle the initialization of a certain kind of entity, e.g.,
146/// arrays, vectors, struct/union types, scalars, etc. The
147/// InitListChecker itself performs a recursive walk of the subobject
148/// structure of the type to be initialized, while stepping through
149/// the initializer list one element at a time. The IList and Index
150/// parameters to each of the Check* routines contain the active
151/// (syntactic) initializer list and the index into that initializer
152/// list that represents the current initializer. Each routine is
153/// responsible for moving that Index forward as it consumes elements.
154///
155/// Each Check* routine also has a StructuredList/StructuredIndex
Abramo Bagnara63e7d252011-01-27 19:55:10 +0000156/// arguments, which contains the current "structured" (semantic)
Douglas Gregor9e80f722009-01-29 01:05:33 +0000157/// initializer list and the index into that initializer list where we
158/// are copying initializers as we map them over to the semantic
159/// list. Once we have completed our recursive walk of the subobject
160/// structure, we will have constructed a full semantic initializer
161/// list.
162///
163/// C99 designators cause changes in the initializer list traversal,
164/// because they make the initialization "jump" into a specific
165/// subobject and then continue the initialization from that
166/// point. CheckDesignatedInitializer() recursively steps into the
167/// designated subobject and manages backing out the recursion to
168/// initialize the subobjects after the one designated.
Chris Lattner8b419b92009-02-24 22:48:58 +0000169namespace {
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000170class InitListChecker {
Chris Lattner08202542009-02-24 22:50:46 +0000171 Sema &SemaRef;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000172 bool hadError;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000173 bool VerifyOnly; // no diagnostics, no structure building
Sebastian Redlc2235182011-10-16 18:19:28 +0000174 bool AllowBraceElision;
Benjamin Kramera7894162012-02-23 14:48:40 +0000175 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000176 InitListExpr *FullyStructuredList;
Mike Stump1eb44332009-09-09 15:08:12 +0000177
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000178 void CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000179 InitListExpr *ParentIList, QualType T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000180 unsigned &Index, InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000181 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000182 void CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000183 InitListExpr *IList, QualType &T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000184 unsigned &Index, InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000185 unsigned &StructuredIndex,
186 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000187 void CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000188 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000189 bool SubobjectIsDesignatorContext,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000190 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000191 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000192 unsigned &StructuredIndex,
193 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000194 void CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000195 InitListExpr *IList, QualType ElemType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000196 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000197 InitListExpr *StructuredList,
198 unsigned &StructuredIndex);
Eli Friedman0c706c22011-09-19 23:17:44 +0000199 void CheckComplexType(const InitializedEntity &Entity,
200 InitListExpr *IList, QualType DeclType,
201 unsigned &Index,
202 InitListExpr *StructuredList,
203 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000204 void CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000205 InitListExpr *IList, QualType DeclType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000206 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000207 InitListExpr *StructuredList,
208 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000209 void CheckReferenceType(const InitializedEntity &Entity,
210 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +0000211 unsigned &Index,
212 InitListExpr *StructuredList,
213 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000214 void CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000215 InitListExpr *IList, QualType DeclType, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000216 InitListExpr *StructuredList,
217 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000218 void CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +0000219 InitListExpr *IList, QualType DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000220 RecordDecl::field_iterator Field,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000221 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000222 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000223 unsigned &StructuredIndex,
224 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000225 void CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +0000226 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000227 llvm::APSInt elementIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000228 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000229 InitListExpr *StructuredList,
230 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000231 bool CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +0000232 InitListExpr *IList, DesignatedInitExpr *DIE,
Douglas Gregor71199712009-04-15 04:56:10 +0000233 unsigned DesigIdx,
Mike Stump1eb44332009-09-09 15:08:12 +0000234 QualType &CurrentObjectType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000235 RecordDecl::field_iterator *NextField,
236 llvm::APSInt *NextElementIndex,
237 unsigned &Index,
238 InitListExpr *StructuredList,
239 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000240 bool FinishSubobjectInit,
241 bool TopLevelObject);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000242 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
243 QualType CurrentObjectType,
244 InitListExpr *StructuredList,
245 unsigned StructuredIndex,
246 SourceRange InitRange);
Douglas Gregor9e80f722009-01-29 01:05:33 +0000247 void UpdateStructuredListElement(InitListExpr *StructuredList,
248 unsigned &StructuredIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000249 Expr *expr);
250 int numArrayElements(QualType DeclType);
251 int numStructUnionElements(QualType DeclType);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000252
Douglas Gregord6d37de2009-12-22 00:05:34 +0000253 void FillInValueInitForField(unsigned Init, FieldDecl *Field,
254 const InitializedEntity &ParentEntity,
255 InitListExpr *ILE, bool &RequiresSecondPass);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000256 void FillInValueInitializations(const InitializedEntity &Entity,
257 InitListExpr *ILE, bool &RequiresSecondPass);
Eli Friedmanf40fd6b2011-08-23 22:24:57 +0000258 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
259 Expr *InitExpr, FieldDecl *Field,
260 bool TopLevelObject);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000261 void CheckValueInitializable(const InitializedEntity &Entity);
262
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000263public:
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000264 InitListChecker(Sema &S, const InitializedEntity &Entity,
Sebastian Redlc2235182011-10-16 18:19:28 +0000265 InitListExpr *IL, QualType &T, bool VerifyOnly,
266 bool AllowBraceElision);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000267 bool HadError() { return hadError; }
268
269 // @brief Retrieves the fully-structured initializer list used for
270 // semantic analysis and code generation.
271 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
272};
Chris Lattner8b419b92009-02-24 22:48:58 +0000273} // end anonymous namespace
Chris Lattner68355a52009-01-29 05:10:57 +0000274
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000275void InitListChecker::CheckValueInitializable(const InitializedEntity &Entity) {
276 assert(VerifyOnly &&
277 "CheckValueInitializable is only inteded for verification mode.");
278
279 SourceLocation Loc;
280 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
281 true);
282 InitializationSequence InitSeq(SemaRef, Entity, Kind, 0, 0);
283 if (InitSeq.Failed())
284 hadError = true;
285}
286
Douglas Gregord6d37de2009-12-22 00:05:34 +0000287void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
288 const InitializedEntity &ParentEntity,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000289 InitListExpr *ILE,
Douglas Gregord6d37de2009-12-22 00:05:34 +0000290 bool &RequiresSecondPass) {
Daniel Dunbar96a00142012-03-09 18:35:03 +0000291 SourceLocation Loc = ILE->getLocStart();
Douglas Gregord6d37de2009-12-22 00:05:34 +0000292 unsigned NumInits = ILE->getNumInits();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000293 InitializedEntity MemberEntity
Douglas Gregord6d37de2009-12-22 00:05:34 +0000294 = InitializedEntity::InitializeMember(Field, &ParentEntity);
295 if (Init >= NumInits || !ILE->getInit(Init)) {
296 // FIXME: We probably don't need to handle references
297 // specially here, since value-initialization of references is
298 // handled in InitializationSequence.
299 if (Field->getType()->isReferenceType()) {
300 // C++ [dcl.init.aggr]p9:
301 // If an incomplete or empty initializer-list leaves a
302 // member of reference type uninitialized, the program is
303 // ill-formed.
304 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
305 << Field->getType()
306 << ILE->getSyntacticForm()->getSourceRange();
307 SemaRef.Diag(Field->getLocation(),
308 diag::note_uninit_reference_member);
309 hadError = true;
310 return;
311 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000312
Douglas Gregord6d37de2009-12-22 00:05:34 +0000313 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
314 true);
315 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, 0, 0);
316 if (!InitSeq) {
317 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, 0, 0);
318 hadError = true;
319 return;
320 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000321
John McCall60d7b3a2010-08-24 06:29:42 +0000322 ExprResult MemberInit
John McCallf312b1e2010-08-26 23:41:50 +0000323 = InitSeq.Perform(SemaRef, MemberEntity, Kind, MultiExprArg());
Douglas Gregord6d37de2009-12-22 00:05:34 +0000324 if (MemberInit.isInvalid()) {
325 hadError = true;
326 return;
327 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000328
Douglas Gregord6d37de2009-12-22 00:05:34 +0000329 if (hadError) {
330 // Do nothing
331 } else if (Init < NumInits) {
332 ILE->setInit(Init, MemberInit.takeAs<Expr>());
Sebastian Redl7491c492011-06-05 13:59:11 +0000333 } else if (InitSeq.isConstructorInitialization()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000334 // Value-initialization requires a constructor call, so
335 // extend the initializer list to include the constructor
336 // call and make a note that we'll need to take another pass
337 // through the initializer list.
Ted Kremenek709210f2010-04-13 23:39:13 +0000338 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
Douglas Gregord6d37de2009-12-22 00:05:34 +0000339 RequiresSecondPass = true;
340 }
341 } else if (InitListExpr *InnerILE
342 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000343 FillInValueInitializations(MemberEntity, InnerILE,
344 RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000345}
346
Douglas Gregor4c678342009-01-28 21:54:33 +0000347/// Recursively replaces NULL values within the given initializer list
348/// with expressions that perform value-initialization of the
349/// appropriate type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000350void
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000351InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
352 InitListExpr *ILE,
353 bool &RequiresSecondPass) {
Mike Stump1eb44332009-09-09 15:08:12 +0000354 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
Douglas Gregor930d8b52009-01-30 22:09:00 +0000355 "Should not have void type");
Daniel Dunbar96a00142012-03-09 18:35:03 +0000356 SourceLocation Loc = ILE->getLocStart();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000357 if (ILE->getSyntacticForm())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000358 Loc = ILE->getSyntacticForm()->getLocStart();
Mike Stump1eb44332009-09-09 15:08:12 +0000359
Ted Kremenek6217b802009-07-29 21:53:49 +0000360 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000361 if (RType->getDecl()->isUnion() &&
362 ILE->getInitializedFieldInUnion())
363 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
364 Entity, ILE, RequiresSecondPass);
365 else {
366 unsigned Init = 0;
367 for (RecordDecl::field_iterator
368 Field = RType->getDecl()->field_begin(),
369 FieldEnd = RType->getDecl()->field_end();
370 Field != FieldEnd; ++Field) {
371 if (Field->isUnnamedBitfield())
372 continue;
Douglas Gregor4c678342009-01-28 21:54:33 +0000373
Douglas Gregord6d37de2009-12-22 00:05:34 +0000374 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000375 return;
Douglas Gregord6d37de2009-12-22 00:05:34 +0000376
David Blaikie581deb32012-06-06 20:45:41 +0000377 FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000378 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000379 return;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000380
Douglas Gregord6d37de2009-12-22 00:05:34 +0000381 ++Init;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000382
Douglas Gregord6d37de2009-12-22 00:05:34 +0000383 // Only look at the first initialization of a union.
384 if (RType->getDecl()->isUnion())
385 break;
386 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000387 }
388
389 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000390 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000391
392 QualType ElementType;
Mike Stump1eb44332009-09-09 15:08:12 +0000393
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000394 InitializedEntity ElementEntity = Entity;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000395 unsigned NumInits = ILE->getNumInits();
396 unsigned NumElements = NumInits;
Chris Lattner08202542009-02-24 22:50:46 +0000397 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000398 ElementType = AType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000399 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
400 NumElements = CAType->getSize().getZExtValue();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000401 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000402 0, Entity);
John McCall183700f2009-09-21 23:43:11 +0000403 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000404 ElementType = VType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000405 NumElements = VType->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000406 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000407 0, Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000408 } else
Douglas Gregor4c678342009-01-28 21:54:33 +0000409 ElementType = ILE->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000410
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000411
Douglas Gregor87fd7032009-02-02 17:43:21 +0000412 for (unsigned Init = 0; Init != NumElements; ++Init) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000413 if (hadError)
414 return;
415
Anders Carlssond3d824d2010-01-23 04:34:47 +0000416 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
417 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000418 ElementEntity.setElementIndex(Init);
419
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000420 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : 0);
421 if (!InitExpr && !ILE->hasArrayFiller()) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000422 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
423 true);
424 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, 0, 0);
425 if (!InitSeq) {
426 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, 0, 0);
Douglas Gregor87fd7032009-02-02 17:43:21 +0000427 hadError = true;
428 return;
429 }
430
John McCall60d7b3a2010-08-24 06:29:42 +0000431 ExprResult ElementInit
John McCallf312b1e2010-08-26 23:41:50 +0000432 = InitSeq.Perform(SemaRef, ElementEntity, Kind, MultiExprArg());
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000433 if (ElementInit.isInvalid()) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000434 hadError = true;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000435 return;
436 }
437
438 if (hadError) {
439 // Do nothing
440 } else if (Init < NumInits) {
Argyrios Kyrtzidis3e8dc2a2011-04-21 20:03:38 +0000441 // For arrays, just set the expression used for value-initialization
442 // of the "holes" in the array.
443 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
444 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
445 else
446 ILE->setInit(Init, ElementInit.takeAs<Expr>());
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000447 } else {
448 // For arrays, just set the expression used for value-initialization
449 // of the rest of elements and exit.
450 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
451 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
452 return;
453 }
454
Sebastian Redl7491c492011-06-05 13:59:11 +0000455 if (InitSeq.isConstructorInitialization()) {
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000456 // Value-initialization requires a constructor call, so
457 // extend the initializer list to include the constructor
458 // call and make a note that we'll need to take another pass
459 // through the initializer list.
460 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
461 RequiresSecondPass = true;
462 }
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000463 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000464 } else if (InitListExpr *InnerILE
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000465 = dyn_cast_or_null<InitListExpr>(InitExpr))
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000466 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
Douglas Gregor4c678342009-01-28 21:54:33 +0000467 }
468}
469
Chris Lattner68355a52009-01-29 05:10:57 +0000470
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000471InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
Sebastian Redl14b0c192011-09-24 17:48:00 +0000472 InitListExpr *IL, QualType &T,
Sebastian Redlc2235182011-10-16 18:19:28 +0000473 bool VerifyOnly, bool AllowBraceElision)
Richard Smithb6f8d282011-12-20 04:00:21 +0000474 : SemaRef(S), VerifyOnly(VerifyOnly), AllowBraceElision(AllowBraceElision) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000475 hadError = false;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000476
Eli Friedmanb85f7072008-05-19 19:16:24 +0000477 unsigned newIndex = 0;
Douglas Gregor4c678342009-01-28 21:54:33 +0000478 unsigned newStructuredIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000479 FullyStructuredList
Douglas Gregored8a93d2009-03-01 17:12:46 +0000480 = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000481 CheckExplicitInitList(Entity, IL, T, newIndex,
Anders Carlsson46f46592010-01-23 19:55:29 +0000482 FullyStructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000483 /*TopLevelObject=*/true);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000484
Sebastian Redl14b0c192011-09-24 17:48:00 +0000485 if (!hadError && !VerifyOnly) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000486 bool RequiresSecondPass = false;
487 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
Douglas Gregor16006c92009-12-16 18:50:27 +0000488 if (RequiresSecondPass && !hadError)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000489 FillInValueInitializations(Entity, FullyStructuredList,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000490 RequiresSecondPass);
491 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000492}
493
494int InitListChecker::numArrayElements(QualType DeclType) {
Eli Friedman638e1442008-05-25 13:22:35 +0000495 // FIXME: use a proper constant
496 int maxElements = 0x7FFFFFFF;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000497 if (const ConstantArrayType *CAT =
Chris Lattner08202542009-02-24 22:50:46 +0000498 SemaRef.Context.getAsConstantArrayType(DeclType)) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000499 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
500 }
501 return maxElements;
502}
503
504int InitListChecker::numStructUnionElements(QualType DeclType) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000505 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
Douglas Gregor4c678342009-01-28 21:54:33 +0000506 int InitializableMembers = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000507 for (RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000508 Field = structDecl->field_begin(),
509 FieldEnd = structDecl->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +0000510 Field != FieldEnd; ++Field) {
Douglas Gregord61db332011-10-10 17:22:13 +0000511 if (!Field->isUnnamedBitfield())
Douglas Gregor4c678342009-01-28 21:54:33 +0000512 ++InitializableMembers;
513 }
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000514 if (structDecl->isUnion())
Eli Friedmanf84eda32008-05-25 14:03:31 +0000515 return std::min(InitializableMembers, 1);
516 return InitializableMembers - structDecl->hasFlexibleArrayMember();
Steve Naroff0cca7492008-05-01 22:18:59 +0000517}
518
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000519void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000520 InitListExpr *ParentIList,
Douglas Gregor4c678342009-01-28 21:54:33 +0000521 QualType T, unsigned &Index,
522 InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000523 unsigned &StructuredIndex) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000524 int maxElements = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000525
Steve Naroff0cca7492008-05-01 22:18:59 +0000526 if (T->isArrayType())
527 maxElements = numArrayElements(T);
Douglas Gregorfb87b892010-04-26 21:31:17 +0000528 else if (T->isRecordType())
Steve Naroff0cca7492008-05-01 22:18:59 +0000529 maxElements = numStructUnionElements(T);
Eli Friedmanb85f7072008-05-19 19:16:24 +0000530 else if (T->isVectorType())
John McCall183700f2009-09-21 23:43:11 +0000531 maxElements = T->getAs<VectorType>()->getNumElements();
Steve Naroff0cca7492008-05-01 22:18:59 +0000532 else
David Blaikieb219cfc2011-09-23 05:06:16 +0000533 llvm_unreachable("CheckImplicitInitList(): Illegal type");
Eli Friedmanb85f7072008-05-19 19:16:24 +0000534
Eli Friedman402256f2008-05-25 13:49:22 +0000535 if (maxElements == 0) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000536 if (!VerifyOnly)
537 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
538 diag::err_implicit_empty_initializer);
Douglas Gregor4c678342009-01-28 21:54:33 +0000539 ++Index;
Eli Friedman402256f2008-05-25 13:49:22 +0000540 hadError = true;
541 return;
542 }
543
Douglas Gregor4c678342009-01-28 21:54:33 +0000544 // Build a structured initializer list corresponding to this subobject.
545 InitListExpr *StructuredSubobjectInitList
Mike Stump1eb44332009-09-09 15:08:12 +0000546 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
547 StructuredIndex,
Daniel Dunbar96a00142012-03-09 18:35:03 +0000548 SourceRange(ParentIList->getInit(Index)->getLocStart(),
Douglas Gregored8a93d2009-03-01 17:12:46 +0000549 ParentIList->getSourceRange().getEnd()));
Douglas Gregor4c678342009-01-28 21:54:33 +0000550 unsigned StructuredSubobjectInitIndex = 0;
Eli Friedmanb85f7072008-05-19 19:16:24 +0000551
Douglas Gregor4c678342009-01-28 21:54:33 +0000552 // Check the element types and build the structural subobject.
Douglas Gregor87fd7032009-02-02 17:43:21 +0000553 unsigned StartIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000554 CheckListElementTypes(Entity, ParentIList, T,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000555 /*SubobjectIsDesignatorContext=*/false, Index,
Mike Stump1eb44332009-09-09 15:08:12 +0000556 StructuredSubobjectInitList,
Eli Friedman629f1182011-08-23 20:17:13 +0000557 StructuredSubobjectInitIndex);
Sebastian Redlc2235182011-10-16 18:19:28 +0000558
559 if (VerifyOnly) {
560 if (!AllowBraceElision && (T->isArrayType() || T->isRecordType()))
561 hadError = true;
562 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000563 StructuredSubobjectInitList->setType(T);
Douglas Gregora6457962009-03-20 00:32:56 +0000564
Sebastian Redlc2235182011-10-16 18:19:28 +0000565 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000566 // Update the structured sub-object initializer so that it's ending
567 // range corresponds with the end of the last initializer it used.
568 if (EndIndex < ParentIList->getNumInits()) {
569 SourceLocation EndLoc
570 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
571 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
572 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000573
Sebastian Redlc2235182011-10-16 18:19:28 +0000574 // Complain about missing braces.
Sebastian Redl14b0c192011-09-24 17:48:00 +0000575 if (T->isArrayType() || T->isRecordType()) {
576 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
Sebastian Redlc2235182011-10-16 18:19:28 +0000577 AllowBraceElision ? diag::warn_missing_braces :
578 diag::err_missing_braces)
Sebastian Redl14b0c192011-09-24 17:48:00 +0000579 << StructuredSubobjectInitList->getSourceRange()
580 << FixItHint::CreateInsertion(
581 StructuredSubobjectInitList->getLocStart(), "{")
582 << FixItHint::CreateInsertion(
583 SemaRef.PP.getLocForEndOfToken(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000584 StructuredSubobjectInitList->getLocEnd()),
Sebastian Redl14b0c192011-09-24 17:48:00 +0000585 "}");
Sebastian Redlc2235182011-10-16 18:19:28 +0000586 if (!AllowBraceElision)
587 hadError = true;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000588 }
Tanya Lattner1e1d3962010-03-07 04:17:15 +0000589 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000590}
591
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000592void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000593 InitListExpr *IList, QualType &T,
Douglas Gregor4c678342009-01-28 21:54:33 +0000594 unsigned &Index,
595 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000596 unsigned &StructuredIndex,
597 bool TopLevelObject) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000598 assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
Sebastian Redl14b0c192011-09-24 17:48:00 +0000599 if (!VerifyOnly) {
600 SyntacticToSemantic[IList] = StructuredList;
601 StructuredList->setSyntacticForm(IList);
602 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000603 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
Anders Carlsson46f46592010-01-23 19:55:29 +0000604 Index, StructuredList, StructuredIndex, TopLevelObject);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000605 if (!VerifyOnly) {
Eli Friedman5c89c392012-02-23 02:25:10 +0000606 QualType ExprTy = T;
607 if (!ExprTy->isArrayType())
608 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000609 IList->setType(ExprTy);
610 StructuredList->setType(ExprTy);
611 }
Eli Friedman638e1442008-05-25 13:22:35 +0000612 if (hadError)
613 return;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000614
Eli Friedman638e1442008-05-25 13:22:35 +0000615 if (Index < IList->getNumInits()) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000616 // We have leftover initializers
Sebastian Redl14b0c192011-09-24 17:48:00 +0000617 if (VerifyOnly) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000618 if (SemaRef.getLangOpts().CPlusPlus ||
619 (SemaRef.getLangOpts().OpenCL &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000620 IList->getType()->isVectorType())) {
621 hadError = true;
622 }
623 return;
624 }
625
Eli Friedmane5408582009-05-29 20:20:05 +0000626 if (StructuredIndex == 1 &&
627 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000628 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
David Blaikie4e4d0842012-03-11 07:00:24 +0000629 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000630 DK = diag::err_excess_initializers_in_char_array_initializer;
Eli Friedmane5408582009-05-29 20:20:05 +0000631 hadError = true;
632 }
Eli Friedmanbb504d32008-05-19 20:12:18 +0000633 // Special-case
Chris Lattner08202542009-02-24 22:50:46 +0000634 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000635 << IList->getInit(Index)->getSourceRange();
Eli Friedmand8dc2102008-05-20 05:25:56 +0000636 } else if (!T->isIncompleteType()) {
Douglas Gregorb574e562009-01-30 22:26:29 +0000637 // Don't complain for incomplete types, since we'll get an error
638 // elsewhere
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000639 QualType CurrentObjectType = StructuredList->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000640 int initKind =
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000641 CurrentObjectType->isArrayType()? 0 :
642 CurrentObjectType->isVectorType()? 1 :
643 CurrentObjectType->isScalarType()? 2 :
644 CurrentObjectType->isUnionType()? 3 :
645 4;
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000646
647 unsigned DK = diag::warn_excess_initializers;
David Blaikie4e4d0842012-03-11 07:00:24 +0000648 if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmane5408582009-05-29 20:20:05 +0000649 DK = diag::err_excess_initializers;
650 hadError = true;
651 }
David Blaikie4e4d0842012-03-11 07:00:24 +0000652 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
Nate Begeman08634522009-07-07 21:53:06 +0000653 DK = diag::err_excess_initializers;
654 hadError = true;
655 }
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000656
Chris Lattner08202542009-02-24 22:50:46 +0000657 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000658 << initKind << IList->getInit(Index)->getSourceRange();
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000659 }
660 }
Eli Friedmancda25a92008-05-19 20:20:43 +0000661
Sebastian Redl14b0c192011-09-24 17:48:00 +0000662 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
663 !TopLevelObject)
Chris Lattner08202542009-02-24 22:50:46 +0000664 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
Douglas Gregora3a83512009-04-01 23:51:29 +0000665 << IList->getSourceRange()
Douglas Gregor849b2432010-03-31 17:46:05 +0000666 << FixItHint::CreateRemoval(IList->getLocStart())
667 << FixItHint::CreateRemoval(IList->getLocEnd());
Steve Naroff0cca7492008-05-01 22:18:59 +0000668}
669
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000670void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000671 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000672 QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +0000673 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +0000674 unsigned &Index,
675 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000676 unsigned &StructuredIndex,
677 bool TopLevelObject) {
Eli Friedman0c706c22011-09-19 23:17:44 +0000678 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
679 // Explicitly braced initializer for complex type can be real+imaginary
680 // parts.
681 CheckComplexType(Entity, IList, DeclType, Index,
682 StructuredList, StructuredIndex);
683 } else if (DeclType->isScalarType()) {
Anders Carlsson46f46592010-01-23 19:55:29 +0000684 CheckScalarType(Entity, IList, DeclType, Index,
685 StructuredList, StructuredIndex);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000686 } else if (DeclType->isVectorType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000687 CheckVectorType(Entity, IList, DeclType, Index,
Anders Carlsson46f46592010-01-23 19:55:29 +0000688 StructuredList, StructuredIndex);
Richard Smith20599392012-07-07 08:35:56 +0000689 } else if (DeclType->isRecordType()) {
690 assert(DeclType->isAggregateType() &&
691 "non-aggregate records should be handed in CheckSubElementType");
692 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
693 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
694 SubobjectIsDesignatorContext, Index,
695 StructuredList, StructuredIndex,
696 TopLevelObject);
697 } else if (DeclType->isArrayType()) {
698 llvm::APSInt Zero(
699 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
700 false);
701 CheckArrayType(Entity, IList, DeclType, Zero,
702 SubobjectIsDesignatorContext, Index,
703 StructuredList, StructuredIndex);
Steve Naroff61353522008-08-10 16:05:48 +0000704 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
705 // This type is invalid, issue a diagnostic.
Douglas Gregor4c678342009-01-28 21:54:33 +0000706 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000707 if (!VerifyOnly)
708 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
709 << DeclType;
Eli Friedmand8dc2102008-05-20 05:25:56 +0000710 hadError = true;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000711 } else if (DeclType->isReferenceType()) {
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000712 CheckReferenceType(Entity, IList, DeclType, Index,
713 StructuredList, StructuredIndex);
John McCallc12c5bb2010-05-15 11:32:37 +0000714 } else if (DeclType->isObjCObjectType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000715 if (!VerifyOnly)
716 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
717 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000718 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000719 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000720 if (!VerifyOnly)
721 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
722 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000723 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000724 }
725}
726
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000727void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000728 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000729 QualType ElemType,
Douglas Gregor4c678342009-01-28 21:54:33 +0000730 unsigned &Index,
731 InitListExpr *StructuredList,
732 unsigned &StructuredIndex) {
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000733 Expr *expr = IList->getInit(Index);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000734 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
Richard Smith20599392012-07-07 08:35:56 +0000735 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
736 unsigned newIndex = 0;
737 unsigned newStructuredIndex = 0;
738 InitListExpr *newStructuredList
739 = getStructuredSubobjectInit(IList, Index, ElemType,
740 StructuredList, StructuredIndex,
741 SubInitList->getSourceRange());
742 CheckExplicitInitList(Entity, SubInitList, ElemType, newIndex,
743 newStructuredList, newStructuredIndex);
744 ++StructuredIndex;
745 ++Index;
746 return;
747 }
748 assert(SemaRef.getLangOpts().CPlusPlus &&
749 "non-aggregate records are only possible in C++");
750 // C++ initialization is handled later.
751 }
752
753 if (ElemType->isScalarType()) {
John McCallfef8b342011-02-21 07:57:55 +0000754 return CheckScalarType(Entity, IList, ElemType, Index,
755 StructuredList, StructuredIndex);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000756 } else if (ElemType->isReferenceType()) {
John McCallfef8b342011-02-21 07:57:55 +0000757 return CheckReferenceType(Entity, IList, ElemType, Index,
758 StructuredList, StructuredIndex);
759 }
Anders Carlssond28b4282009-08-27 17:18:13 +0000760
John McCallfef8b342011-02-21 07:57:55 +0000761 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
762 // arrayType can be incomplete if we're initializing a flexible
763 // array member. There's nothing we can do with the completed
764 // type here, though.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000765
John McCallfef8b342011-02-21 07:57:55 +0000766 if (Expr *Str = IsStringInit(expr, arrayType, SemaRef.Context)) {
Eli Friedman8a5d9292011-09-26 19:09:09 +0000767 if (!VerifyOnly) {
768 CheckStringInit(Str, ElemType, arrayType, SemaRef);
769 UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
770 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000771 ++Index;
John McCallfef8b342011-02-21 07:57:55 +0000772 return;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000773 }
John McCallfef8b342011-02-21 07:57:55 +0000774
775 // Fall through for subaggregate initialization.
776
David Blaikie4e4d0842012-03-11 07:00:24 +0000777 } else if (SemaRef.getLangOpts().CPlusPlus) {
John McCallfef8b342011-02-21 07:57:55 +0000778 // C++ [dcl.init.aggr]p12:
779 // All implicit type conversions (clause 4) are considered when
Sebastian Redl5d3d41d2011-09-24 17:47:39 +0000780 // initializing the aggregate member with an initializer from
John McCallfef8b342011-02-21 07:57:55 +0000781 // an initializer-list. If the initializer can initialize a
782 // member, the member is initialized. [...]
783
784 // FIXME: Better EqualLoc?
785 InitializationKind Kind =
786 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
787 InitializationSequence Seq(SemaRef, Entity, Kind, &expr, 1);
788
789 if (Seq) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000790 if (!VerifyOnly) {
Richard Smithb6f8d282011-12-20 04:00:21 +0000791 ExprResult Result =
792 Seq.Perform(SemaRef, Entity, Kind, MultiExprArg(&expr, 1));
793 if (Result.isInvalid())
794 hadError = true;
John McCallfef8b342011-02-21 07:57:55 +0000795
Sebastian Redl14b0c192011-09-24 17:48:00 +0000796 UpdateStructuredListElement(StructuredList, StructuredIndex,
Richard Smithb6f8d282011-12-20 04:00:21 +0000797 Result.takeAs<Expr>());
Sebastian Redl14b0c192011-09-24 17:48:00 +0000798 }
John McCallfef8b342011-02-21 07:57:55 +0000799 ++Index;
800 return;
801 }
802
803 // Fall through for subaggregate initialization
804 } else {
805 // C99 6.7.8p13:
806 //
807 // The initializer for a structure or union object that has
808 // automatic storage duration shall be either an initializer
809 // list as described below, or a single expression that has
810 // compatible structure or union type. In the latter case, the
811 // initial value of the object, including unnamed members, is
812 // that of the expression.
John Wiegley429bb272011-04-08 18:41:53 +0000813 ExprResult ExprRes = SemaRef.Owned(expr);
John McCallfef8b342011-02-21 07:57:55 +0000814 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000815 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
816 !VerifyOnly)
John McCallfef8b342011-02-21 07:57:55 +0000817 == Sema::Compatible) {
John Wiegley429bb272011-04-08 18:41:53 +0000818 if (ExprRes.isInvalid())
819 hadError = true;
820 else {
821 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take());
822 if (ExprRes.isInvalid())
823 hadError = true;
824 }
825 UpdateStructuredListElement(StructuredList, StructuredIndex,
826 ExprRes.takeAs<Expr>());
John McCallfef8b342011-02-21 07:57:55 +0000827 ++Index;
828 return;
829 }
John Wiegley429bb272011-04-08 18:41:53 +0000830 ExprRes.release();
John McCallfef8b342011-02-21 07:57:55 +0000831 // Fall through for subaggregate initialization
832 }
833
834 // C++ [dcl.init.aggr]p12:
835 //
836 // [...] Otherwise, if the member is itself a non-empty
837 // subaggregate, brace elision is assumed and the initializer is
838 // considered for the initialization of the first member of
839 // the subaggregate.
David Blaikie4e4d0842012-03-11 07:00:24 +0000840 if (!SemaRef.getLangOpts().OpenCL &&
Tanya Lattner61b4bc82011-07-15 23:07:01 +0000841 (ElemType->isAggregateType() || ElemType->isVectorType())) {
John McCallfef8b342011-02-21 07:57:55 +0000842 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
843 StructuredIndex);
844 ++StructuredIndex;
845 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000846 if (!VerifyOnly) {
847 // We cannot initialize this element, so let
848 // PerformCopyInitialization produce the appropriate diagnostic.
849 SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
850 SemaRef.Owned(expr),
851 /*TopLevelOfInitList=*/true);
852 }
John McCallfef8b342011-02-21 07:57:55 +0000853 hadError = true;
854 ++Index;
855 ++StructuredIndex;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000856 }
Eli Friedmanb85f7072008-05-19 19:16:24 +0000857}
858
Eli Friedman0c706c22011-09-19 23:17:44 +0000859void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
860 InitListExpr *IList, QualType DeclType,
861 unsigned &Index,
862 InitListExpr *StructuredList,
863 unsigned &StructuredIndex) {
864 assert(Index == 0 && "Index in explicit init list must be zero");
865
866 // As an extension, clang supports complex initializers, which initialize
867 // a complex number component-wise. When an explicit initializer list for
868 // a complex number contains two two initializers, this extension kicks in:
869 // it exepcts the initializer list to contain two elements convertible to
870 // the element type of the complex type. The first element initializes
871 // the real part, and the second element intitializes the imaginary part.
872
873 if (IList->getNumInits() != 2)
874 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
875 StructuredIndex);
876
877 // This is an extension in C. (The builtin _Complex type does not exist
878 // in the C++ standard.)
David Blaikie4e4d0842012-03-11 07:00:24 +0000879 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
Eli Friedman0c706c22011-09-19 23:17:44 +0000880 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
881 << IList->getSourceRange();
882
883 // Initialize the complex number.
884 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
885 InitializedEntity ElementEntity =
886 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
887
888 for (unsigned i = 0; i < 2; ++i) {
889 ElementEntity.setElementIndex(Index);
890 CheckSubElementType(ElementEntity, IList, elementType, Index,
891 StructuredList, StructuredIndex);
892 }
893}
894
895
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000896void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000897 InitListExpr *IList, QualType DeclType,
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000898 unsigned &Index,
Douglas Gregor4c678342009-01-28 21:54:33 +0000899 InitListExpr *StructuredList,
900 unsigned &StructuredIndex) {
John McCallb934c2d2010-11-11 00:46:36 +0000901 if (Index >= IList->getNumInits()) {
Richard Smith6b130222011-10-18 21:39:00 +0000902 if (!VerifyOnly)
903 SemaRef.Diag(IList->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +0000904 SemaRef.getLangOpts().CPlusPlus11 ?
Richard Smith6b130222011-10-18 21:39:00 +0000905 diag::warn_cxx98_compat_empty_scalar_initializer :
906 diag::err_empty_scalar_initializer)
907 << IList->getSourceRange();
Richard Smith80ad52f2013-01-02 11:42:31 +0000908 hadError = !SemaRef.getLangOpts().CPlusPlus11;
Douglas Gregor4c678342009-01-28 21:54:33 +0000909 ++Index;
910 ++StructuredIndex;
Eli Friedmanbb504d32008-05-19 20:12:18 +0000911 return;
Steve Naroff0cca7492008-05-01 22:18:59 +0000912 }
John McCallb934c2d2010-11-11 00:46:36 +0000913
914 Expr *expr = IList->getInit(Index);
915 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000916 if (!VerifyOnly)
917 SemaRef.Diag(SubIList->getLocStart(),
918 diag::warn_many_braces_around_scalar_init)
919 << SubIList->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +0000920
921 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
922 StructuredIndex);
923 return;
924 } else if (isa<DesignatedInitExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000925 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +0000926 SemaRef.Diag(expr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +0000927 diag::err_designator_for_scalar_init)
928 << DeclType << expr->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +0000929 hadError = true;
930 ++Index;
931 ++StructuredIndex;
932 return;
933 }
934
Sebastian Redl14b0c192011-09-24 17:48:00 +0000935 if (VerifyOnly) {
936 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
937 hadError = true;
938 ++Index;
939 return;
940 }
941
John McCallb934c2d2010-11-11 00:46:36 +0000942 ExprResult Result =
943 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +0000944 SemaRef.Owned(expr),
945 /*TopLevelOfInitList=*/true);
John McCallb934c2d2010-11-11 00:46:36 +0000946
947 Expr *ResultExpr = 0;
948
949 if (Result.isInvalid())
950 hadError = true; // types weren't compatible.
951 else {
952 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000953
John McCallb934c2d2010-11-11 00:46:36 +0000954 if (ResultExpr != expr) {
955 // The type was promoted, update initializer list.
956 IList->setInit(Index, ResultExpr);
957 }
958 }
959 if (hadError)
960 ++StructuredIndex;
961 else
962 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
963 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +0000964}
965
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000966void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
967 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +0000968 unsigned &Index,
969 InitListExpr *StructuredList,
970 unsigned &StructuredIndex) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000971 if (Index >= IList->getNumInits()) {
Mike Stump390b4cc2009-05-16 07:39:55 +0000972 // FIXME: It would be wonderful if we could point at the actual member. In
973 // general, it would be useful to pass location information down the stack,
974 // so that we know the location (or decl) of the "current object" being
975 // initialized.
Sebastian Redl14b0c192011-09-24 17:48:00 +0000976 if (!VerifyOnly)
977 SemaRef.Diag(IList->getLocStart(),
978 diag::err_init_reference_member_uninitialized)
979 << DeclType
980 << IList->getSourceRange();
Douglas Gregor930d8b52009-01-30 22:09:00 +0000981 hadError = true;
982 ++Index;
983 ++StructuredIndex;
984 return;
985 }
Sebastian Redl14b0c192011-09-24 17:48:00 +0000986
987 Expr *expr = IList->getInit(Index);
Richard Smith80ad52f2013-01-02 11:42:31 +0000988 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000989 if (!VerifyOnly)
990 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
991 << DeclType << IList->getSourceRange();
992 hadError = true;
993 ++Index;
994 ++StructuredIndex;
995 return;
996 }
997
998 if (VerifyOnly) {
999 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1000 hadError = true;
1001 ++Index;
1002 return;
1003 }
1004
1005 ExprResult Result =
1006 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1007 SemaRef.Owned(expr),
1008 /*TopLevelOfInitList=*/true);
1009
1010 if (Result.isInvalid())
1011 hadError = true;
1012
1013 expr = Result.takeAs<Expr>();
1014 IList->setInit(Index, expr);
1015
1016 if (hadError)
1017 ++StructuredIndex;
1018 else
1019 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1020 ++Index;
Douglas Gregor930d8b52009-01-30 22:09:00 +00001021}
1022
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001023void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +00001024 InitListExpr *IList, QualType DeclType,
Douglas Gregor4c678342009-01-28 21:54:33 +00001025 unsigned &Index,
1026 InitListExpr *StructuredList,
1027 unsigned &StructuredIndex) {
John McCall20e047a2010-10-30 00:11:39 +00001028 const VectorType *VT = DeclType->getAs<VectorType>();
1029 unsigned maxElements = VT->getNumElements();
1030 unsigned numEltsInit = 0;
1031 QualType elementType = VT->getElementType();
Anders Carlsson46f46592010-01-23 19:55:29 +00001032
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001033 if (Index >= IList->getNumInits()) {
1034 // Make sure the element type can be value-initialized.
1035 if (VerifyOnly)
1036 CheckValueInitializable(
1037 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity));
1038 return;
1039 }
1040
David Blaikie4e4d0842012-03-11 07:00:24 +00001041 if (!SemaRef.getLangOpts().OpenCL) {
John McCall20e047a2010-10-30 00:11:39 +00001042 // If the initializing element is a vector, try to copy-initialize
1043 // instead of breaking it apart (which is doomed to failure anyway).
1044 Expr *Init = IList->getInit(Index);
1045 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001046 if (VerifyOnly) {
1047 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(Init)))
1048 hadError = true;
1049 ++Index;
1050 return;
1051 }
1052
John McCall20e047a2010-10-30 00:11:39 +00001053 ExprResult Result =
1054 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001055 SemaRef.Owned(Init),
1056 /*TopLevelOfInitList=*/true);
John McCall20e047a2010-10-30 00:11:39 +00001057
1058 Expr *ResultExpr = 0;
1059 if (Result.isInvalid())
1060 hadError = true; // types weren't compatible.
1061 else {
1062 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001063
John McCall20e047a2010-10-30 00:11:39 +00001064 if (ResultExpr != Init) {
1065 // The type was promoted, update initializer list.
1066 IList->setInit(Index, ResultExpr);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001067 }
1068 }
John McCall20e047a2010-10-30 00:11:39 +00001069 if (hadError)
1070 ++StructuredIndex;
1071 else
Sebastian Redl14b0c192011-09-24 17:48:00 +00001072 UpdateStructuredListElement(StructuredList, StructuredIndex,
1073 ResultExpr);
John McCall20e047a2010-10-30 00:11:39 +00001074 ++Index;
1075 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001076 }
Mike Stump1eb44332009-09-09 15:08:12 +00001077
John McCall20e047a2010-10-30 00:11:39 +00001078 InitializedEntity ElementEntity =
1079 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001080
John McCall20e047a2010-10-30 00:11:39 +00001081 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1082 // Don't attempt to go past the end of the init list
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001083 if (Index >= IList->getNumInits()) {
1084 if (VerifyOnly)
1085 CheckValueInitializable(ElementEntity);
John McCall20e047a2010-10-30 00:11:39 +00001086 break;
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001087 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001088
John McCall20e047a2010-10-30 00:11:39 +00001089 ElementEntity.setElementIndex(Index);
1090 CheckSubElementType(ElementEntity, IList, elementType, Index,
1091 StructuredList, StructuredIndex);
1092 }
1093 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001094 }
John McCall20e047a2010-10-30 00:11:39 +00001095
1096 InitializedEntity ElementEntity =
1097 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001098
John McCall20e047a2010-10-30 00:11:39 +00001099 // OpenCL initializers allows vectors to be constructed from vectors.
1100 for (unsigned i = 0; i < maxElements; ++i) {
1101 // Don't attempt to go past the end of the init list
1102 if (Index >= IList->getNumInits())
1103 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001104
John McCall20e047a2010-10-30 00:11:39 +00001105 ElementEntity.setElementIndex(Index);
1106
1107 QualType IType = IList->getInit(Index)->getType();
1108 if (!IType->isVectorType()) {
1109 CheckSubElementType(ElementEntity, IList, elementType, Index,
1110 StructuredList, StructuredIndex);
1111 ++numEltsInit;
1112 } else {
1113 QualType VecType;
1114 const VectorType *IVT = IType->getAs<VectorType>();
1115 unsigned numIElts = IVT->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001116
John McCall20e047a2010-10-30 00:11:39 +00001117 if (IType->isExtVectorType())
1118 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1119 else
1120 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
Bob Wilsone86d78c2010-11-10 21:56:12 +00001121 IVT->getVectorKind());
John McCall20e047a2010-10-30 00:11:39 +00001122 CheckSubElementType(ElementEntity, IList, VecType, Index,
1123 StructuredList, StructuredIndex);
1124 numEltsInit += numIElts;
1125 }
1126 }
1127
1128 // OpenCL requires all elements to be initialized.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001129 if (numEltsInit != maxElements) {
1130 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001131 SemaRef.Diag(IList->getLocStart(),
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001132 diag::err_vector_incorrect_num_initializers)
1133 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1134 hadError = true;
1135 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001136}
1137
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001138void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +00001139 InitListExpr *IList, QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001140 llvm::APSInt elementIndex,
Mike Stump1eb44332009-09-09 15:08:12 +00001141 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001142 unsigned &Index,
1143 InitListExpr *StructuredList,
1144 unsigned &StructuredIndex) {
John McCallce6c9b72011-02-21 07:22:22 +00001145 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1146
Steve Naroff0cca7492008-05-01 22:18:59 +00001147 // Check for the special-case of initializing an array with a string.
1148 if (Index < IList->getNumInits()) {
John McCallce6c9b72011-02-21 07:22:22 +00001149 if (Expr *Str = IsStringInit(IList->getInit(Index), arrayType,
Chris Lattner79e079d2009-02-24 23:10:27 +00001150 SemaRef.Context)) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001151 // We place the string literal directly into the resulting
1152 // initializer list. This is the only place where the structure
1153 // of the structured initializer list doesn't match exactly,
1154 // because doing so would involve allocating one character
1155 // constant for each string.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001156 if (!VerifyOnly) {
Eli Friedman8a5d9292011-09-26 19:09:09 +00001157 CheckStringInit(Str, DeclType, arrayType, SemaRef);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001158 UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
1159 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1160 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001161 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001162 return;
1163 }
1164 }
John McCallce6c9b72011-02-21 07:22:22 +00001165 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
Eli Friedman638e1442008-05-25 13:22:35 +00001166 // Check for VLAs; in standard C it would be possible to check this
1167 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1168 // them in all sorts of strange places).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001169 if (!VerifyOnly)
1170 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1171 diag::err_variable_object_no_init)
1172 << VAT->getSizeExpr()->getSourceRange();
Eli Friedman638e1442008-05-25 13:22:35 +00001173 hadError = true;
Douglas Gregor4c678342009-01-28 21:54:33 +00001174 ++Index;
1175 ++StructuredIndex;
Eli Friedman638e1442008-05-25 13:22:35 +00001176 return;
1177 }
1178
Douglas Gregor05c13a32009-01-22 00:58:24 +00001179 // We might know the maximum number of elements in advance.
Douglas Gregor4c678342009-01-28 21:54:33 +00001180 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1181 elementIndex.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001182 bool maxElementsKnown = false;
John McCallce6c9b72011-02-21 07:22:22 +00001183 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00001184 maxElements = CAT->getSize();
Jay Foad9f71a8f2010-12-07 08:25:34 +00001185 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001186 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001187 maxElementsKnown = true;
1188 }
1189
John McCallce6c9b72011-02-21 07:22:22 +00001190 QualType elementType = arrayType->getElementType();
Douglas Gregor05c13a32009-01-22 00:58:24 +00001191 while (Index < IList->getNumInits()) {
1192 Expr *Init = IList->getInit(Index);
1193 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001194 // If we're not the subobject that matches up with the '{' for
1195 // the designator, we shouldn't be handling the
1196 // designator. Return immediately.
1197 if (!SubobjectIsDesignatorContext)
1198 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001199
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001200 // Handle this designated initializer. elementIndex will be
1201 // updated to be the next array element we'll initialize.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001202 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001203 DeclType, 0, &elementIndex, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001204 StructuredList, StructuredIndex, true,
1205 false)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001206 hadError = true;
1207 continue;
1208 }
1209
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001210 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001211 maxElements = maxElements.extend(elementIndex.getBitWidth());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001212 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001213 elementIndex = elementIndex.extend(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001214 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001215
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001216 // If the array is of incomplete type, keep track of the number of
1217 // elements in the initializer.
1218 if (!maxElementsKnown && elementIndex > maxElements)
1219 maxElements = elementIndex;
1220
Douglas Gregor05c13a32009-01-22 00:58:24 +00001221 continue;
1222 }
1223
1224 // If we know the maximum number of elements, and we've already
1225 // hit it, stop consuming elements in the initializer list.
1226 if (maxElementsKnown && elementIndex == maxElements)
Steve Naroff0cca7492008-05-01 22:18:59 +00001227 break;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001228
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001229 InitializedEntity ElementEntity =
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001230 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001231 Entity);
1232 // Check this element.
1233 CheckSubElementType(ElementEntity, IList, elementType, Index,
1234 StructuredList, StructuredIndex);
Douglas Gregor05c13a32009-01-22 00:58:24 +00001235 ++elementIndex;
1236
1237 // If the array is of incomplete type, keep track of the number of
1238 // elements in the initializer.
1239 if (!maxElementsKnown && elementIndex > maxElements)
1240 maxElements = elementIndex;
Steve Naroff0cca7492008-05-01 22:18:59 +00001241 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001242 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +00001243 // If this is an incomplete array type, the actual type needs to
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001244 // be calculated here.
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001245 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001246 if (maxElements == Zero) {
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001247 // Sizing an array implicitly to zero is not allowed by ISO C,
1248 // but is supported by GNU.
Chris Lattner08202542009-02-24 22:50:46 +00001249 SemaRef.Diag(IList->getLocStart(),
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001250 diag::ext_typecheck_zero_array_size);
Steve Naroff0cca7492008-05-01 22:18:59 +00001251 }
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001252
Mike Stump1eb44332009-09-09 15:08:12 +00001253 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001254 ArrayType::Normal, 0);
Steve Naroff0cca7492008-05-01 22:18:59 +00001255 }
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001256 if (!hadError && VerifyOnly) {
1257 // Check if there are any members of the array that get value-initialized.
1258 // If so, check if doing that is possible.
1259 // FIXME: This needs to detect holes left by designated initializers too.
1260 if (maxElementsKnown && elementIndex < maxElements)
1261 CheckValueInitializable(InitializedEntity::InitializeElement(
1262 SemaRef.Context, 0, Entity));
1263 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001264}
1265
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001266bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1267 Expr *InitExpr,
1268 FieldDecl *Field,
1269 bool TopLevelObject) {
1270 // Handle GNU flexible array initializers.
1271 unsigned FlexArrayDiag;
1272 if (isa<InitListExpr>(InitExpr) &&
1273 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1274 // Empty flexible array init always allowed as an extension
1275 FlexArrayDiag = diag::ext_flexible_array_init;
David Blaikie4e4d0842012-03-11 07:00:24 +00001276 } else if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001277 // Disallow flexible array init in C++; it is not required for gcc
1278 // compatibility, and it needs work to IRGen correctly in general.
1279 FlexArrayDiag = diag::err_flexible_array_init;
1280 } else if (!TopLevelObject) {
1281 // Disallow flexible array init on non-top-level object
1282 FlexArrayDiag = diag::err_flexible_array_init;
1283 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1284 // Disallow flexible array init on anything which is not a variable.
1285 FlexArrayDiag = diag::err_flexible_array_init;
1286 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1287 // Disallow flexible array init on local variables.
1288 FlexArrayDiag = diag::err_flexible_array_init;
1289 } else {
1290 // Allow other cases.
1291 FlexArrayDiag = diag::ext_flexible_array_init;
1292 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001293
1294 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001295 SemaRef.Diag(InitExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001296 FlexArrayDiag)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001297 << InitExpr->getLocStart();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001298 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1299 << Field;
1300 }
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001301
1302 return FlexArrayDiag != diag::ext_flexible_array_init;
1303}
1304
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001305void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +00001306 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +00001307 QualType DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001308 RecordDecl::field_iterator Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001309 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001310 unsigned &Index,
1311 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001312 unsigned &StructuredIndex,
1313 bool TopLevelObject) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001314 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001315
Eli Friedmanb85f7072008-05-19 19:16:24 +00001316 // If the record is invalid, some of it's members are invalid. To avoid
1317 // confusion, we forgo checking the intializer for the entire record.
1318 if (structDecl->isInvalidDecl()) {
Richard Smith72ab2772012-09-28 21:23:50 +00001319 // Assume it was supposed to consume a single initializer.
1320 ++Index;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001321 hadError = true;
1322 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001323 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001324
1325 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001326 // Value-initialize the first named member of the union.
1327 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1328 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1329 Field != FieldEnd; ++Field) {
1330 if (Field->getDeclName()) {
1331 if (VerifyOnly)
1332 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001333 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001334 else
David Blaikie581deb32012-06-06 20:45:41 +00001335 StructuredList->setInitializedFieldInUnion(*Field);
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001336 break;
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001337 }
1338 }
1339 return;
1340 }
1341
Douglas Gregor05c13a32009-01-22 00:58:24 +00001342 // If structDecl is a forward declaration, this loop won't do
1343 // anything except look at designated initializers; That's okay,
1344 // because an error should get printed out elsewhere. It might be
1345 // worthwhile to skip over the rest of the initializer, though.
Ted Kremenek6217b802009-07-29 21:53:49 +00001346 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001347 RecordDecl::field_iterator FieldEnd = RD->field_end();
Douglas Gregordfb5e592009-02-12 19:00:39 +00001348 bool InitializedSomething = false;
John McCall80639de2010-03-11 19:32:38 +00001349 bool CheckForMissingFields = true;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001350 while (Index < IList->getNumInits()) {
1351 Expr *Init = IList->getInit(Index);
1352
1353 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001354 // If we're not the subobject that matches up with the '{' for
1355 // the designator, we shouldn't be handling the
1356 // designator. Return immediately.
1357 if (!SubobjectIsDesignatorContext)
1358 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001359
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001360 // Handle this designated initializer. Field will be updated to
1361 // the next field that we'll be initializing.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001362 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001363 DeclType, &Field, 0, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001364 StructuredList, StructuredIndex,
1365 true, TopLevelObject))
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001366 hadError = true;
1367
Douglas Gregordfb5e592009-02-12 19:00:39 +00001368 InitializedSomething = true;
John McCall80639de2010-03-11 19:32:38 +00001369
1370 // Disable check for missing fields when designators are used.
1371 // This matches gcc behaviour.
1372 CheckForMissingFields = false;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001373 continue;
1374 }
1375
1376 if (Field == FieldEnd) {
1377 // We've run out of fields. We're done.
1378 break;
1379 }
1380
Douglas Gregordfb5e592009-02-12 19:00:39 +00001381 // We've already initialized a member of a union. We're done.
1382 if (InitializedSomething && DeclType->isUnionType())
1383 break;
1384
Douglas Gregor44b43212008-12-11 16:49:14 +00001385 // If we've hit the flexible array member at the end, we're done.
1386 if (Field->getType()->isIncompleteArrayType())
1387 break;
1388
Douglas Gregor0bb76892009-01-29 16:53:55 +00001389 if (Field->isUnnamedBitfield()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001390 // Don't initialize unnamed bitfields, e.g. "int : 20;"
Douglas Gregor05c13a32009-01-22 00:58:24 +00001391 ++Field;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001392 continue;
Steve Naroff0cca7492008-05-01 22:18:59 +00001393 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001394
Douglas Gregor54001c12011-06-29 21:51:31 +00001395 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001396 bool InvalidUse;
1397 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001398 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001399 else
David Blaikie581deb32012-06-06 20:45:41 +00001400 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001401 IList->getInit(Index)->getLocStart());
1402 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001403 ++Index;
1404 ++Field;
1405 hadError = true;
1406 continue;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001407 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001408
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001409 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001410 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001411 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1412 StructuredList, StructuredIndex);
Douglas Gregordfb5e592009-02-12 19:00:39 +00001413 InitializedSomething = true;
Douglas Gregor0bb76892009-01-29 16:53:55 +00001414
Sebastian Redl14b0c192011-09-24 17:48:00 +00001415 if (DeclType->isUnionType() && !VerifyOnly) {
Douglas Gregor0bb76892009-01-29 16:53:55 +00001416 // Initialize the first field within the union.
David Blaikie581deb32012-06-06 20:45:41 +00001417 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001418 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00001419
1420 ++Field;
Steve Naroff0cca7492008-05-01 22:18:59 +00001421 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001422
John McCall80639de2010-03-11 19:32:38 +00001423 // Emit warnings for missing struct field initializers.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001424 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1425 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1426 !DeclType->isUnionType()) {
John McCall80639de2010-03-11 19:32:38 +00001427 // It is possible we have one or more unnamed bitfields remaining.
1428 // Find first (if any) named field and emit warning.
1429 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1430 it != end; ++it) {
1431 if (!it->isUnnamedBitfield()) {
1432 SemaRef.Diag(IList->getSourceRange().getEnd(),
1433 diag::warn_missing_field_initializers) << it->getName();
1434 break;
1435 }
1436 }
1437 }
1438
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001439 // Check that any remaining fields can be value-initialized.
1440 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1441 !Field->getType()->isIncompleteArrayType()) {
1442 // FIXME: Should check for holes left by designated initializers too.
1443 for (; Field != FieldEnd && !hadError; ++Field) {
1444 if (!Field->isUnnamedBitfield())
1445 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001446 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001447 }
1448 }
1449
Mike Stump1eb44332009-09-09 15:08:12 +00001450 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
Douglas Gregora6457962009-03-20 00:32:56 +00001451 Index >= IList->getNumInits())
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001452 return;
1453
David Blaikie581deb32012-06-06 20:45:41 +00001454 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001455 TopLevelObject)) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001456 hadError = true;
Douglas Gregora6457962009-03-20 00:32:56 +00001457 ++Index;
1458 return;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001459 }
1460
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001461 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001462 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001463
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001464 if (isa<InitListExpr>(IList->getInit(Index)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001465 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001466 StructuredList, StructuredIndex);
1467 else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001468 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson987dc6a2010-01-23 20:47:59 +00001469 StructuredList, StructuredIndex);
Steve Naroff0cca7492008-05-01 22:18:59 +00001470}
Steve Naroff0cca7492008-05-01 22:18:59 +00001471
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001472/// \brief Expand a field designator that refers to a member of an
1473/// anonymous struct or union into a series of field designators that
1474/// refers to the field within the appropriate subobject.
1475///
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001476static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
Mike Stump1eb44332009-09-09 15:08:12 +00001477 DesignatedInitExpr *DIE,
1478 unsigned DesigIdx,
Francois Picheta0e27f02010-12-22 03:46:10 +00001479 IndirectFieldDecl *IndirectField) {
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001480 typedef DesignatedInitExpr::Designator Designator;
1481
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001482 // Build the replacement designators.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001483 SmallVector<Designator, 4> Replacements;
Francois Picheta0e27f02010-12-22 03:46:10 +00001484 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1485 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1486 if (PI + 1 == PE)
Mike Stump1eb44332009-09-09 15:08:12 +00001487 Replacements.push_back(Designator((IdentifierInfo *)0,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001488 DIE->getDesignator(DesigIdx)->getDotLoc(),
1489 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1490 else
1491 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1492 SourceLocation()));
Francois Picheta0e27f02010-12-22 03:46:10 +00001493 assert(isa<FieldDecl>(*PI));
1494 Replacements.back().setField(cast<FieldDecl>(*PI));
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001495 }
1496
1497 // Expand the current designator into the set of replacement
1498 // designators, so we have a full subobject path down to where the
1499 // member of the anonymous struct/union is actually stored.
Douglas Gregor319d57f2010-01-06 23:17:19 +00001500 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001501 &Replacements[0] + Replacements.size());
Francois Picheta0e27f02010-12-22 03:46:10 +00001502}
Mike Stump1eb44332009-09-09 15:08:12 +00001503
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001504/// \brief Given an implicit anonymous field, search the IndirectField that
Francois Picheta0e27f02010-12-22 03:46:10 +00001505/// corresponds to FieldName.
1506static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField,
1507 IdentifierInfo *FieldName) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001508 if (!FieldName)
1509 return 0;
1510
Francois Picheta0e27f02010-12-22 03:46:10 +00001511 assert(AnonField->isAnonymousStructOrUnion());
1512 Decl *NextDecl = AnonField->getNextDeclInContext();
Aaron Ballman3e78b192012-02-09 22:16:56 +00001513 while (IndirectFieldDecl *IF =
1514 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001515 if (FieldName == IF->getAnonField()->getIdentifier())
Francois Picheta0e27f02010-12-22 03:46:10 +00001516 return IF;
1517 NextDecl = NextDecl->getNextDeclInContext();
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001518 }
Francois Picheta0e27f02010-12-22 03:46:10 +00001519 return 0;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001520}
1521
Sebastian Redl14b0c192011-09-24 17:48:00 +00001522static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1523 DesignatedInitExpr *DIE) {
1524 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1525 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1526 for (unsigned I = 0; I < NumIndexExprs; ++I)
1527 IndexExprs[I] = DIE->getSubExpr(I + 1);
1528 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001529 DIE->size(), IndexExprs,
1530 DIE->getEqualOrColonLoc(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001531 DIE->usesGNUSyntax(), DIE->getInit());
1532}
1533
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001534namespace {
1535
1536// Callback to only accept typo corrections that are for field members of
1537// the given struct or union.
1538class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1539 public:
1540 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1541 : Record(RD) {}
1542
1543 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1544 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1545 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1546 }
1547
1548 private:
1549 RecordDecl *Record;
1550};
1551
1552}
1553
Douglas Gregor05c13a32009-01-22 00:58:24 +00001554/// @brief Check the well-formedness of a C99 designated initializer.
1555///
1556/// Determines whether the designated initializer @p DIE, which
1557/// resides at the given @p Index within the initializer list @p
1558/// IList, is well-formed for a current object of type @p DeclType
1559/// (C99 6.7.8). The actual subobject that this designator refers to
Mike Stump1eb44332009-09-09 15:08:12 +00001560/// within the current subobject is returned in either
Douglas Gregor4c678342009-01-28 21:54:33 +00001561/// @p NextField or @p NextElementIndex (whichever is appropriate).
Douglas Gregor05c13a32009-01-22 00:58:24 +00001562///
1563/// @param IList The initializer list in which this designated
1564/// initializer occurs.
1565///
Douglas Gregor71199712009-04-15 04:56:10 +00001566/// @param DIE The designated initializer expression.
1567///
1568/// @param DesigIdx The index of the current designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001569///
Dmitri Gribenko70517ca2012-08-23 17:58:28 +00001570/// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
Douglas Gregor05c13a32009-01-22 00:58:24 +00001571/// into which the designation in @p DIE should refer.
1572///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001573/// @param NextField If non-NULL and the first designator in @p DIE is
1574/// a field, this will be set to the field declaration corresponding
1575/// to the field named by the designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001576///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001577/// @param NextElementIndex If non-NULL and the first designator in @p
1578/// DIE is an array designator or GNU array-range designator, this
1579/// will be set to the last index initialized by this designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001580///
1581/// @param Index Index into @p IList where the designated initializer
1582/// @p DIE occurs.
1583///
Douglas Gregor4c678342009-01-28 21:54:33 +00001584/// @param StructuredList The initializer list expression that
1585/// describes all of the subobject initializers in the order they'll
1586/// actually be initialized.
1587///
Douglas Gregor05c13a32009-01-22 00:58:24 +00001588/// @returns true if there was an error, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00001589bool
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001590InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001591 InitListExpr *IList,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001592 DesignatedInitExpr *DIE,
1593 unsigned DesigIdx,
1594 QualType &CurrentObjectType,
1595 RecordDecl::field_iterator *NextField,
1596 llvm::APSInt *NextElementIndex,
1597 unsigned &Index,
1598 InitListExpr *StructuredList,
1599 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001600 bool FinishSubobjectInit,
1601 bool TopLevelObject) {
Douglas Gregor71199712009-04-15 04:56:10 +00001602 if (DesigIdx == DIE->size()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001603 // Check the actual initialization for the designated object type.
1604 bool prevHadError = hadError;
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001605
1606 // Temporarily remove the designator expression from the
1607 // initializer list that the child calls see, so that we don't try
1608 // to re-process the designator.
1609 unsigned OldIndex = Index;
1610 IList->setInit(OldIndex, DIE->getInit());
1611
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001612 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001613 StructuredList, StructuredIndex);
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001614
1615 // Restore the designated initializer expression in the syntactic
1616 // form of the initializer list.
1617 if (IList->getInit(OldIndex) != DIE->getInit())
1618 DIE->setInit(IList->getInit(OldIndex));
1619 IList->setInit(OldIndex, DIE);
1620
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001621 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001622 }
1623
Douglas Gregor71199712009-04-15 04:56:10 +00001624 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001625 bool IsFirstDesignator = (DesigIdx == 0);
1626 if (!VerifyOnly) {
1627 assert((IsFirstDesignator || StructuredList) &&
1628 "Need a non-designated initializer list to start from");
1629
1630 // Determine the structural initializer list that corresponds to the
1631 // current subobject.
Benjamin Kramera7894162012-02-23 14:48:40 +00001632 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001633 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1634 StructuredList, StructuredIndex,
Erik Verbruggen65d78312012-12-25 14:51:39 +00001635 SourceRange(D->getLocStart(),
1636 DIE->getLocEnd()));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001637 assert(StructuredList && "Expected a structured initializer list");
1638 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001639
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001640 if (D->isFieldDesignator()) {
1641 // C99 6.7.8p7:
1642 //
1643 // If a designator has the form
1644 //
1645 // . identifier
1646 //
1647 // then the current object (defined below) shall have
1648 // structure or union type and the identifier shall be the
Mike Stump1eb44332009-09-09 15:08:12 +00001649 // name of a member of that type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001650 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001651 if (!RT) {
1652 SourceLocation Loc = D->getDotLoc();
1653 if (Loc.isInvalid())
1654 Loc = D->getFieldLoc();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001655 if (!VerifyOnly)
1656 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
David Blaikie4e4d0842012-03-11 07:00:24 +00001657 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001658 ++Index;
1659 return true;
1660 }
1661
Douglas Gregor4c678342009-01-28 21:54:33 +00001662 // Note: we perform a linear search of the fields here, despite
1663 // the fact that we have a faster lookup method, because we always
1664 // need to compute the field's index.
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001665 FieldDecl *KnownField = D->getField();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001666 IdentifierInfo *FieldName = D->getFieldName();
Douglas Gregor4c678342009-01-28 21:54:33 +00001667 unsigned FieldIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001668 RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001669 Field = RT->getDecl()->field_begin(),
1670 FieldEnd = RT->getDecl()->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +00001671 for (; Field != FieldEnd; ++Field) {
1672 if (Field->isUnnamedBitfield())
1673 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001674
Francois Picheta0e27f02010-12-22 03:46:10 +00001675 // If we find a field representing an anonymous field, look in the
1676 // IndirectFieldDecl that follow for the designated initializer.
1677 if (!KnownField && Field->isAnonymousStructOrUnion()) {
1678 if (IndirectFieldDecl *IF =
David Blaikie581deb32012-06-06 20:45:41 +00001679 FindIndirectFieldDesignator(*Field, FieldName)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001680 // In verify mode, don't modify the original.
1681 if (VerifyOnly)
1682 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
Francois Picheta0e27f02010-12-22 03:46:10 +00001683 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF);
1684 D = DIE->getDesignator(DesigIdx);
1685 break;
1686 }
1687 }
David Blaikie581deb32012-06-06 20:45:41 +00001688 if (KnownField && KnownField == *Field)
Douglas Gregor022d13d2010-10-08 20:44:28 +00001689 break;
1690 if (FieldName && FieldName == Field->getIdentifier())
Douglas Gregor4c678342009-01-28 21:54:33 +00001691 break;
1692
1693 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001694 }
1695
Douglas Gregor4c678342009-01-28 21:54:33 +00001696 if (Field == FieldEnd) {
Benjamin Kramera41ee492011-09-25 02:41:26 +00001697 if (VerifyOnly) {
1698 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001699 return true; // No typo correction when just trying this out.
Benjamin Kramera41ee492011-09-25 02:41:26 +00001700 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001701
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001702 // There was no normal field in the struct with the designated
1703 // name. Perform another lookup for this name, which may find
1704 // something that we can't designate (e.g., a member function),
1705 // may find nothing, or may find a member of an anonymous
Mike Stump1eb44332009-09-09 15:08:12 +00001706 // struct/union.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001707 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001708 FieldDecl *ReplacementField = 0;
David Blaikie3bc93e32012-12-19 00:45:41 +00001709 if (Lookup.empty()) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001710 // Name lookup didn't find anything. Determine whether this
1711 // was a typo for another field name.
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001712 FieldInitializerValidatorCCC Validator(RT->getDecl());
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001713 TypoCorrection Corrected = SemaRef.CorrectTypo(
1714 DeclarationNameInfo(FieldName, D->getFieldLoc()),
Kaelyn Uhrain16e46dd2012-01-31 23:49:25 +00001715 Sema::LookupMemberName, /*Scope=*/0, /*SS=*/0, Validator,
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001716 RT->getDecl());
1717 if (Corrected) {
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001718 std::string CorrectedStr(
David Blaikie4e4d0842012-03-11 07:00:24 +00001719 Corrected.getAsString(SemaRef.getLangOpts()));
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001720 std::string CorrectedQuotedStr(
David Blaikie4e4d0842012-03-11 07:00:24 +00001721 Corrected.getQuoted(SemaRef.getLangOpts()));
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001722 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001723 SemaRef.Diag(D->getFieldLoc(),
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001724 diag::err_field_designator_unknown_suggest)
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001725 << FieldName << CurrentObjectType << CorrectedQuotedStr
1726 << FixItHint::CreateReplacement(D->getFieldLoc(), CorrectedStr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001727 SemaRef.Diag(ReplacementField->getLocation(),
Douglas Gregord8bba9c2011-06-28 16:20:02 +00001728 diag::note_previous_decl) << CorrectedQuotedStr;
Benjamin Kramera41ee492011-09-25 02:41:26 +00001729 hadError = true;
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001730 } else {
1731 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1732 << FieldName << CurrentObjectType;
1733 ++Index;
1734 return true;
1735 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001736 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001737
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001738 if (!ReplacementField) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001739 // Name lookup found something, but it wasn't a field.
Chris Lattner08202542009-02-24 22:50:46 +00001740 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
Douglas Gregor4c678342009-01-28 21:54:33 +00001741 << FieldName;
David Blaikie3bc93e32012-12-19 00:45:41 +00001742 SemaRef.Diag(Lookup.front()->getLocation(),
Douglas Gregor4c678342009-01-28 21:54:33 +00001743 diag::note_field_designator_found);
Eli Friedmanba79fc22009-04-16 17:49:48 +00001744 ++Index;
1745 return true;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001746 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001747
Francois Picheta0e27f02010-12-22 03:46:10 +00001748 if (!KnownField) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001749 // The replacement field comes from typo correction; find it
1750 // in the list of fields.
1751 FieldIndex = 0;
1752 Field = RT->getDecl()->field_begin();
1753 for (; Field != FieldEnd; ++Field) {
1754 if (Field->isUnnamedBitfield())
1755 continue;
1756
David Blaikie581deb32012-06-06 20:45:41 +00001757 if (ReplacementField == *Field ||
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001758 Field->getIdentifier() == ReplacementField->getIdentifier())
1759 break;
1760
1761 ++FieldIndex;
1762 }
1763 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001764 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001765
1766 // All of the fields of a union are located at the same place in
1767 // the initializer list.
Douglas Gregor0bb76892009-01-29 16:53:55 +00001768 if (RT->getDecl()->isUnion()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001769 FieldIndex = 0;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001770 if (!VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001771 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001772 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001773
Douglas Gregor54001c12011-06-29 21:51:31 +00001774 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001775 bool InvalidUse;
1776 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001777 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001778 else
David Blaikie581deb32012-06-06 20:45:41 +00001779 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001780 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001781 ++Index;
1782 return true;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001783 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001784
Sebastian Redl14b0c192011-09-24 17:48:00 +00001785 if (!VerifyOnly) {
1786 // Update the designator with the field declaration.
David Blaikie581deb32012-06-06 20:45:41 +00001787 D->setField(*Field);
Mike Stump1eb44332009-09-09 15:08:12 +00001788
Sebastian Redl14b0c192011-09-24 17:48:00 +00001789 // Make sure that our non-designated initializer list has space
1790 // for a subobject corresponding to this field.
1791 if (FieldIndex >= StructuredList->getNumInits())
1792 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1793 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001794
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001795 // This designator names a flexible array member.
1796 if (Field->getType()->isIncompleteArrayType()) {
1797 bool Invalid = false;
Douglas Gregor71199712009-04-15 04:56:10 +00001798 if ((DesigIdx + 1) != DIE->size()) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001799 // We can't designate an object within the flexible array
1800 // member (because GCC doesn't allow it).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001801 if (!VerifyOnly) {
1802 DesignatedInitExpr::Designator *NextD
1803 = DIE->getDesignator(DesigIdx + 1);
Erik Verbruggen65d78312012-12-25 14:51:39 +00001804 SemaRef.Diag(NextD->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001805 diag::err_designator_into_flexible_array_member)
Erik Verbruggen65d78312012-12-25 14:51:39 +00001806 << SourceRange(NextD->getLocStart(),
1807 DIE->getLocEnd());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001808 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001809 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001810 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001811 Invalid = true;
1812 }
1813
Chris Lattner9046c222010-10-10 17:49:49 +00001814 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
1815 !isa<StringLiteral>(DIE->getInit())) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001816 // The initializer is not an initializer list.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001817 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001818 SemaRef.Diag(DIE->getInit()->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001819 diag::err_flexible_array_init_needs_braces)
1820 << DIE->getInit()->getSourceRange();
1821 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001822 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001823 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001824 Invalid = true;
1825 }
1826
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001827 // Check GNU flexible array initializer.
David Blaikie581deb32012-06-06 20:45:41 +00001828 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001829 TopLevelObject))
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001830 Invalid = true;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001831
1832 if (Invalid) {
1833 ++Index;
1834 return true;
1835 }
1836
1837 // Initialize the array.
1838 bool prevHadError = hadError;
1839 unsigned newStructuredIndex = FieldIndex;
1840 unsigned OldIndex = Index;
1841 IList->setInit(Index, DIE->getInit());
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001842
1843 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001844 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001845 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001846 StructuredList, newStructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001847
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001848 IList->setInit(OldIndex, DIE);
1849 if (hadError && !prevHadError) {
1850 ++Field;
1851 ++FieldIndex;
1852 if (NextField)
1853 *NextField = Field;
1854 StructuredIndex = FieldIndex;
1855 return true;
1856 }
1857 } else {
1858 // Recurse to check later designated subobjects.
David Blaikie262bc182012-04-30 02:36:29 +00001859 QualType FieldType = Field->getType();
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001860 unsigned newStructuredIndex = FieldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001861
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001862 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001863 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001864 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
1865 FieldType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001866 StructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001867 true, false))
1868 return true;
1869 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001870
1871 // Find the position of the next field to be initialized in this
1872 // subobject.
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001873 ++Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001874 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001875
1876 // If this the first designator, our caller will continue checking
1877 // the rest of this struct/class/union subobject.
1878 if (IsFirstDesignator) {
1879 if (NextField)
1880 *NextField = Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001881 StructuredIndex = FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001882 return false;
1883 }
1884
Douglas Gregor34e79462009-01-28 23:36:17 +00001885 if (!FinishSubobjectInit)
1886 return false;
1887
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001888 // We've already initialized something in the union; we're done.
1889 if (RT->getDecl()->isUnion())
1890 return hadError;
1891
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001892 // Check the remaining fields within this class/struct/union subobject.
1893 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001894
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001895 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001896 StructuredList, FieldIndex);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001897 return hadError && !prevHadError;
1898 }
1899
1900 // C99 6.7.8p6:
1901 //
1902 // If a designator has the form
1903 //
1904 // [ constant-expression ]
1905 //
1906 // then the current object (defined below) shall have array
1907 // type and the expression shall be an integer constant
1908 // expression. If the array is of unknown size, any
1909 // nonnegative value is valid.
1910 //
1911 // Additionally, cope with the GNU extension that permits
1912 // designators of the form
1913 //
1914 // [ constant-expression ... constant-expression ]
Chris Lattner08202542009-02-24 22:50:46 +00001915 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001916 if (!AT) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001917 if (!VerifyOnly)
1918 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
1919 << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001920 ++Index;
1921 return true;
1922 }
1923
1924 Expr *IndexExpr = 0;
Douglas Gregor34e79462009-01-28 23:36:17 +00001925 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
1926 if (D->isArrayDesignator()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001927 IndexExpr = DIE->getArrayIndex(*D);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001928 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor34e79462009-01-28 23:36:17 +00001929 DesignatedEndIndex = DesignatedStartIndex;
1930 } else {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001931 assert(D->isArrayRangeDesignator() && "Need array-range designator");
Douglas Gregor34e79462009-01-28 23:36:17 +00001932
Mike Stump1eb44332009-09-09 15:08:12 +00001933 DesignatedStartIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001934 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
Mike Stump1eb44332009-09-09 15:08:12 +00001935 DesignatedEndIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00001936 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001937 IndexExpr = DIE->getArrayRangeEnd(*D);
Douglas Gregor34e79462009-01-28 23:36:17 +00001938
Chris Lattnere0fd8322011-02-19 22:28:58 +00001939 // Codegen can't handle evaluating array range designators that have side
1940 // effects, because we replicate the AST value for each initialized element.
1941 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
1942 // elements with something that has a side effect, so codegen can emit an
1943 // "error unsupported" error instead of miscompiling the app.
1944 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
Sebastian Redl14b0c192011-09-24 17:48:00 +00001945 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
Douglas Gregora9c87802009-01-29 19:42:23 +00001946 FullyStructuredList->sawArrayRangeDesignator();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001947 }
1948
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001949 if (isa<ConstantArrayType>(AT)) {
1950 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
Jay Foad9f71a8f2010-12-07 08:25:34 +00001951 DesignatedStartIndex
1952 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00001953 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
Jay Foad9f71a8f2010-12-07 08:25:34 +00001954 DesignatedEndIndex
1955 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00001956 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
1957 if (DesignatedEndIndex >= MaxElements) {
Eli Friedmana4e20e12011-09-26 18:53:43 +00001958 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001959 SemaRef.Diag(IndexExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001960 diag::err_array_designator_too_large)
1961 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
1962 << IndexExpr->getSourceRange();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001963 ++Index;
1964 return true;
1965 }
Douglas Gregor34e79462009-01-28 23:36:17 +00001966 } else {
1967 // Make sure the bit-widths and signedness match.
1968 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001969 DesignatedEndIndex
1970 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
Chris Lattner3bf68932009-04-25 21:59:05 +00001971 else if (DesignatedStartIndex.getBitWidth() <
1972 DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001973 DesignatedStartIndex
1974 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00001975 DesignatedStartIndex.setIsUnsigned(true);
1976 DesignatedEndIndex.setIsUnsigned(true);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001977 }
Mike Stump1eb44332009-09-09 15:08:12 +00001978
Douglas Gregor4c678342009-01-28 21:54:33 +00001979 // Make sure that our non-designated initializer list has space
1980 // for a subobject corresponding to this array element.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001981 if (!VerifyOnly &&
1982 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
Mike Stump1eb44332009-09-09 15:08:12 +00001983 StructuredList->resizeInits(SemaRef.Context,
Douglas Gregor34e79462009-01-28 23:36:17 +00001984 DesignatedEndIndex.getZExtValue() + 1);
Douglas Gregor4c678342009-01-28 21:54:33 +00001985
Douglas Gregor34e79462009-01-28 23:36:17 +00001986 // Repeatedly perform subobject initializations in the range
1987 // [DesignatedStartIndex, DesignatedEndIndex].
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001988
Douglas Gregor34e79462009-01-28 23:36:17 +00001989 // Move to the next designator
1990 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
1991 unsigned OldIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001992
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001993 InitializedEntity ElementEntity =
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001994 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001995
Douglas Gregor34e79462009-01-28 23:36:17 +00001996 while (DesignatedStartIndex <= DesignatedEndIndex) {
1997 // Recurse to check later designated subobjects.
1998 QualType ElementType = AT->getElementType();
1999 Index = OldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002000
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002001 ElementEntity.setElementIndex(ElementIndex);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002002 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2003 ElementType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002004 StructuredList, ElementIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00002005 (DesignatedStartIndex == DesignatedEndIndex),
2006 false))
Douglas Gregor34e79462009-01-28 23:36:17 +00002007 return true;
2008
2009 // Move to the next index in the array that we'll be initializing.
2010 ++DesignatedStartIndex;
2011 ElementIndex = DesignatedStartIndex.getZExtValue();
2012 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002013
2014 // If this the first designator, our caller will continue checking
2015 // the rest of this array subobject.
2016 if (IsFirstDesignator) {
2017 if (NextElementIndex)
Douglas Gregor34e79462009-01-28 23:36:17 +00002018 *NextElementIndex = DesignatedStartIndex;
Douglas Gregor4c678342009-01-28 21:54:33 +00002019 StructuredIndex = ElementIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002020 return false;
2021 }
Mike Stump1eb44332009-09-09 15:08:12 +00002022
Douglas Gregor34e79462009-01-28 23:36:17 +00002023 if (!FinishSubobjectInit)
2024 return false;
2025
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002026 // Check the remaining elements within this array subobject.
Douglas Gregor05c13a32009-01-22 00:58:24 +00002027 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002028 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
Anders Carlsson784f6992010-01-23 20:13:41 +00002029 /*SubobjectIsDesignatorContext=*/false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002030 StructuredList, ElementIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002031 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002032}
2033
Douglas Gregor4c678342009-01-28 21:54:33 +00002034// Get the structured initializer list for a subobject of type
2035// @p CurrentObjectType.
2036InitListExpr *
2037InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2038 QualType CurrentObjectType,
2039 InitListExpr *StructuredList,
2040 unsigned StructuredIndex,
2041 SourceRange InitRange) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002042 if (VerifyOnly)
2043 return 0; // No structured list in verification-only mode.
Douglas Gregor4c678342009-01-28 21:54:33 +00002044 Expr *ExistingInit = 0;
2045 if (!StructuredList)
Benjamin Kramera7894162012-02-23 14:48:40 +00002046 ExistingInit = SyntacticToSemantic.lookup(IList);
Douglas Gregor4c678342009-01-28 21:54:33 +00002047 else if (StructuredIndex < StructuredList->getNumInits())
2048 ExistingInit = StructuredList->getInit(StructuredIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002049
Douglas Gregor4c678342009-01-28 21:54:33 +00002050 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2051 return Result;
2052
2053 if (ExistingInit) {
2054 // We are creating an initializer list that initializes the
2055 // subobjects of the current object, but there was already an
2056 // initialization that completely initialized the current
2057 // subobject, e.g., by a compound literal:
Mike Stump1eb44332009-09-09 15:08:12 +00002058 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002059 // struct X { int a, b; };
2060 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
Mike Stump1eb44332009-09-09 15:08:12 +00002061 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002062 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2063 // designated initializer re-initializes the whole
2064 // subobject [0], overwriting previous initializers.
Mike Stump1eb44332009-09-09 15:08:12 +00002065 SemaRef.Diag(InitRange.getBegin(),
Douglas Gregored8a93d2009-03-01 17:12:46 +00002066 diag::warn_subobject_initializer_overrides)
Douglas Gregor4c678342009-01-28 21:54:33 +00002067 << InitRange;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002068 SemaRef.Diag(ExistingInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002069 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002070 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002071 << ExistingInit->getSourceRange();
2072 }
2073
Mike Stump1eb44332009-09-09 15:08:12 +00002074 InitListExpr *Result
Ted Kremenek709210f2010-04-13 23:39:13 +00002075 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00002076 InitRange.getBegin(), MultiExprArg(),
Ted Kremenekba7bc552010-02-19 01:50:18 +00002077 InitRange.getEnd());
Douglas Gregored8a93d2009-03-01 17:12:46 +00002078
Eli Friedman5c89c392012-02-23 02:25:10 +00002079 QualType ResultType = CurrentObjectType;
2080 if (!ResultType->isArrayType())
2081 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2082 Result->setType(ResultType);
Douglas Gregor4c678342009-01-28 21:54:33 +00002083
Douglas Gregorfa219202009-03-20 23:58:33 +00002084 // Pre-allocate storage for the structured initializer list.
2085 unsigned NumElements = 0;
Douglas Gregor08457732009-03-21 18:13:52 +00002086 unsigned NumInits = 0;
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002087 bool GotNumInits = false;
2088 if (!StructuredList) {
Douglas Gregor08457732009-03-21 18:13:52 +00002089 NumInits = IList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002090 GotNumInits = true;
2091 } else if (Index < IList->getNumInits()) {
2092 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
Douglas Gregor08457732009-03-21 18:13:52 +00002093 NumInits = SubList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002094 GotNumInits = true;
2095 }
Douglas Gregor08457732009-03-21 18:13:52 +00002096 }
2097
Mike Stump1eb44332009-09-09 15:08:12 +00002098 if (const ArrayType *AType
Douglas Gregorfa219202009-03-20 23:58:33 +00002099 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2100 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2101 NumElements = CAType->getSize().getZExtValue();
2102 // Simple heuristic so that we don't allocate a very large
2103 // initializer with many empty entries at the end.
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002104 if (GotNumInits && NumElements > NumInits)
Douglas Gregorfa219202009-03-20 23:58:33 +00002105 NumElements = 0;
2106 }
John McCall183700f2009-09-21 23:43:11 +00002107 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
Douglas Gregorfa219202009-03-20 23:58:33 +00002108 NumElements = VType->getNumElements();
Ted Kremenek6217b802009-07-29 21:53:49 +00002109 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
Douglas Gregorfa219202009-03-20 23:58:33 +00002110 RecordDecl *RDecl = RType->getDecl();
2111 if (RDecl->isUnion())
2112 NumElements = 1;
2113 else
Mike Stump1eb44332009-09-09 15:08:12 +00002114 NumElements = std::distance(RDecl->field_begin(),
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002115 RDecl->field_end());
Douglas Gregorfa219202009-03-20 23:58:33 +00002116 }
2117
Ted Kremenek709210f2010-04-13 23:39:13 +00002118 Result->reserveInits(SemaRef.Context, NumElements);
Douglas Gregorfa219202009-03-20 23:58:33 +00002119
Douglas Gregor4c678342009-01-28 21:54:33 +00002120 // Link this new initializer list into the structured initializer
2121 // lists.
2122 if (StructuredList)
Ted Kremenek709210f2010-04-13 23:39:13 +00002123 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
Douglas Gregor4c678342009-01-28 21:54:33 +00002124 else {
2125 Result->setSyntacticForm(IList);
2126 SyntacticToSemantic[IList] = Result;
2127 }
2128
2129 return Result;
2130}
2131
2132/// Update the initializer at index @p StructuredIndex within the
2133/// structured initializer list to the value @p expr.
2134void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2135 unsigned &StructuredIndex,
2136 Expr *expr) {
2137 // No structured initializer list to update
2138 if (!StructuredList)
2139 return;
2140
Ted Kremenek709210f2010-04-13 23:39:13 +00002141 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2142 StructuredIndex, expr)) {
Douglas Gregor4c678342009-01-28 21:54:33 +00002143 // This initializer overwrites a previous initializer. Warn.
Daniel Dunbar96a00142012-03-09 18:35:03 +00002144 SemaRef.Diag(expr->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002145 diag::warn_initializer_overrides)
2146 << expr->getSourceRange();
Daniel Dunbar96a00142012-03-09 18:35:03 +00002147 SemaRef.Diag(PrevInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002148 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002149 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002150 << PrevInit->getSourceRange();
2151 }
Mike Stump1eb44332009-09-09 15:08:12 +00002152
Douglas Gregor4c678342009-01-28 21:54:33 +00002153 ++StructuredIndex;
2154}
2155
Douglas Gregor05c13a32009-01-22 00:58:24 +00002156/// Check that the given Index expression is a valid array designator
Richard Smith282e7e62012-02-04 09:53:13 +00002157/// value. This is essentially just a wrapper around
Chris Lattner3bf68932009-04-25 21:59:05 +00002158/// VerifyIntegerConstantExpression that also checks for negative values
Douglas Gregor05c13a32009-01-22 00:58:24 +00002159/// and produces a reasonable diagnostic if there is a
Richard Smith282e7e62012-02-04 09:53:13 +00002160/// failure. Returns the index expression, possibly with an implicit cast
2161/// added, on success. If everything went okay, Value will receive the
2162/// value of the constant expression.
2163static ExprResult
Chris Lattner3bf68932009-04-25 21:59:05 +00002164CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00002165 SourceLocation Loc = Index->getLocStart();
Douglas Gregor05c13a32009-01-22 00:58:24 +00002166
2167 // Make sure this is an integer constant expression.
Richard Smith282e7e62012-02-04 09:53:13 +00002168 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2169 if (Result.isInvalid())
2170 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002171
Chris Lattner3bf68932009-04-25 21:59:05 +00002172 if (Value.isSigned() && Value.isNegative())
2173 return S.Diag(Loc, diag::err_array_designator_negative)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002174 << Value.toString(10) << Index->getSourceRange();
2175
Douglas Gregor53d3d8e2009-01-23 21:04:18 +00002176 Value.setIsUnsigned(true);
Richard Smith282e7e62012-02-04 09:53:13 +00002177 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002178}
2179
John McCall60d7b3a2010-08-24 06:29:42 +00002180ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
Nick Lewycky7663f392010-11-20 01:29:55 +00002181 SourceLocation Loc,
2182 bool GNUSyntax,
2183 ExprResult Init) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00002184 typedef DesignatedInitExpr::Designator ASTDesignator;
2185
2186 bool Invalid = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002187 SmallVector<ASTDesignator, 32> Designators;
2188 SmallVector<Expr *, 32> InitExpressions;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002189
2190 // Build designators and check array designator expressions.
2191 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2192 const Designator &D = Desig.getDesignator(Idx);
2193 switch (D.getKind()) {
2194 case Designator::FieldDesignator:
Mike Stump1eb44332009-09-09 15:08:12 +00002195 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002196 D.getFieldLoc()));
2197 break;
2198
2199 case Designator::ArrayDesignator: {
2200 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2201 llvm::APSInt IndexValue;
Richard Smith282e7e62012-02-04 09:53:13 +00002202 if (!Index->isTypeDependent() && !Index->isValueDependent())
2203 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take();
2204 if (!Index)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002205 Invalid = true;
2206 else {
2207 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002208 D.getLBracketLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002209 D.getRBracketLoc()));
2210 InitExpressions.push_back(Index);
2211 }
2212 break;
2213 }
2214
2215 case Designator::ArrayRangeDesignator: {
2216 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2217 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2218 llvm::APSInt StartValue;
2219 llvm::APSInt EndValue;
Douglas Gregor9ea62762009-05-21 23:17:49 +00002220 bool StartDependent = StartIndex->isTypeDependent() ||
2221 StartIndex->isValueDependent();
2222 bool EndDependent = EndIndex->isTypeDependent() ||
2223 EndIndex->isValueDependent();
Richard Smith282e7e62012-02-04 09:53:13 +00002224 if (!StartDependent)
2225 StartIndex =
2226 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take();
2227 if (!EndDependent)
2228 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take();
2229
2230 if (!StartIndex || !EndIndex)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002231 Invalid = true;
Douglas Gregord6f584f2009-01-23 22:22:29 +00002232 else {
2233 // Make sure we're comparing values with the same bit width.
Douglas Gregor9ea62762009-05-21 23:17:49 +00002234 if (StartDependent || EndDependent) {
2235 // Nothing to compute.
2236 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002237 EndValue = EndValue.extend(StartValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002238 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002239 StartValue = StartValue.extend(EndValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002240
Douglas Gregorc4bb7bf2009-05-21 23:30:39 +00002241 if (!StartDependent && !EndDependent && EndValue < StartValue) {
Douglas Gregord6f584f2009-01-23 22:22:29 +00002242 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
Mike Stump1eb44332009-09-09 15:08:12 +00002243 << StartValue.toString(10) << EndValue.toString(10)
Douglas Gregord6f584f2009-01-23 22:22:29 +00002244 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2245 Invalid = true;
2246 } else {
2247 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002248 D.getLBracketLoc(),
Douglas Gregord6f584f2009-01-23 22:22:29 +00002249 D.getEllipsisLoc(),
2250 D.getRBracketLoc()));
2251 InitExpressions.push_back(StartIndex);
2252 InitExpressions.push_back(EndIndex);
2253 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00002254 }
2255 break;
2256 }
2257 }
2258 }
2259
2260 if (Invalid || Init.isInvalid())
2261 return ExprError();
2262
2263 // Clear out the expressions within the designation.
2264 Desig.ClearExprs(*this);
2265
2266 DesignatedInitExpr *DIE
Jay Foadbeaaccd2009-05-21 09:52:38 +00002267 = DesignatedInitExpr::Create(Context,
2268 Designators.data(), Designators.size(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00002269 InitExpressions, Loc, GNUSyntax,
2270 Init.takeAs<Expr>());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002271
David Blaikie4e4d0842012-03-11 07:00:24 +00002272 if (!getLangOpts().C99)
Douglas Gregor2d75bbd2011-01-16 16:13:16 +00002273 Diag(DIE->getLocStart(), diag::ext_designated_init)
2274 << DIE->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002275
Douglas Gregor05c13a32009-01-22 00:58:24 +00002276 return Owned(DIE);
2277}
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002278
Douglas Gregor20093b42009-12-09 23:02:17 +00002279//===----------------------------------------------------------------------===//
2280// Initialization entity
2281//===----------------------------------------------------------------------===//
2282
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002283InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002284 const InitializedEntity &Parent)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002285 : Parent(&Parent), Index(Index)
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002286{
Anders Carlssond3d824d2010-01-23 04:34:47 +00002287 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2288 Kind = EK_ArrayElement;
Douglas Gregord6542d82009-12-22 15:35:07 +00002289 Type = AT->getElementType();
Eli Friedman0c706c22011-09-19 23:17:44 +00002290 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
Anders Carlssond3d824d2010-01-23 04:34:47 +00002291 Kind = EK_VectorElement;
Eli Friedman0c706c22011-09-19 23:17:44 +00002292 Type = VT->getElementType();
2293 } else {
2294 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2295 assert(CT && "Unexpected type");
2296 Kind = EK_ComplexElement;
2297 Type = CT->getElementType();
Anders Carlssond3d824d2010-01-23 04:34:47 +00002298 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002299}
2300
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002301InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context,
Anders Carlsson711f34a2010-04-21 19:52:01 +00002302 CXXBaseSpecifier *Base,
2303 bool IsInheritedVirtualBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00002304{
2305 InitializedEntity Result;
2306 Result.Kind = EK_Base;
Anders Carlsson711f34a2010-04-21 19:52:01 +00002307 Result.Base = reinterpret_cast<uintptr_t>(Base);
2308 if (IsInheritedVirtualBase)
2309 Result.Base |= 0x01;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002310
Douglas Gregord6542d82009-12-22 15:35:07 +00002311 Result.Type = Base->getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00002312 return Result;
2313}
2314
Douglas Gregor99a2e602009-12-16 01:38:02 +00002315DeclarationName InitializedEntity::getName() const {
2316 switch (getKind()) {
John McCallf85e1932011-06-15 23:02:42 +00002317 case EK_Parameter: {
2318 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2319 return (D ? D->getDeclName() : DeclarationName());
2320 }
Douglas Gregora188ff22009-12-22 16:09:06 +00002321
2322 case EK_Variable:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002323 case EK_Member:
2324 return VariableOrMember->getDeclName();
2325
Douglas Gregor47736542012-02-15 16:57:26 +00002326 case EK_LambdaCapture:
2327 return Capture.Var->getDeclName();
2328
Douglas Gregor99a2e602009-12-16 01:38:02 +00002329 case EK_Result:
2330 case EK_Exception:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002331 case EK_New:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002332 case EK_Temporary:
2333 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002334 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002335 case EK_ArrayElement:
2336 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002337 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002338 case EK_BlockElement:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002339 return DeclarationName();
2340 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002341
David Blaikie7530c032012-01-17 06:56:22 +00002342 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor99a2e602009-12-16 01:38:02 +00002343}
2344
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002345DeclaratorDecl *InitializedEntity::getDecl() const {
2346 switch (getKind()) {
2347 case EK_Variable:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002348 case EK_Member:
2349 return VariableOrMember;
2350
John McCallf85e1932011-06-15 23:02:42 +00002351 case EK_Parameter:
2352 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2353
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002354 case EK_Result:
2355 case EK_Exception:
2356 case EK_New:
2357 case EK_Temporary:
2358 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002359 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002360 case EK_ArrayElement:
2361 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002362 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002363 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002364 case EK_LambdaCapture:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002365 return 0;
2366 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002367
David Blaikie7530c032012-01-17 06:56:22 +00002368 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002369}
2370
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002371bool InitializedEntity::allowsNRVO() const {
2372 switch (getKind()) {
2373 case EK_Result:
2374 case EK_Exception:
2375 return LocAndNRVO.NRVO;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002376
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002377 case EK_Variable:
2378 case EK_Parameter:
2379 case EK_Member:
2380 case EK_New:
2381 case EK_Temporary:
2382 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002383 case EK_Delegating:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002384 case EK_ArrayElement:
2385 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002386 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002387 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002388 case EK_LambdaCapture:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002389 break;
2390 }
2391
2392 return false;
2393}
2394
Douglas Gregor20093b42009-12-09 23:02:17 +00002395//===----------------------------------------------------------------------===//
2396// Initialization sequence
2397//===----------------------------------------------------------------------===//
2398
2399void InitializationSequence::Step::Destroy() {
2400 switch (Kind) {
2401 case SK_ResolveAddressOfOverloadedFunction:
2402 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002403 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002404 case SK_CastDerivedToBaseLValue:
2405 case SK_BindReference:
2406 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00002407 case SK_ExtraneousCopyToTemporary:
Douglas Gregor20093b42009-12-09 23:02:17 +00002408 case SK_UserConversion:
2409 case SK_QualificationConversionRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002410 case SK_QualificationConversionXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002411 case SK_QualificationConversionLValue:
Douglas Gregord87b61f2009-12-10 17:56:55 +00002412 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002413 case SK_ListConstructorCall:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002414 case SK_UnwrapInitList:
2415 case SK_RewrapInitList:
Douglas Gregor51c56d62009-12-14 20:49:26 +00002416 case SK_ConstructorInitialization:
Douglas Gregor71d17402009-12-15 00:01:57 +00002417 case SK_ZeroInitialization:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002418 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002419 case SK_StringInit:
Douglas Gregor569c3162010-08-07 11:51:51 +00002420 case SK_ObjCObjectConversion:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002421 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00002422 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00002423 case SK_PassByIndirectCopyRestore:
2424 case SK_PassByIndirectRestore:
2425 case SK_ProduceObjCObject:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002426 case SK_StdInitializerList:
Douglas Gregor20093b42009-12-09 23:02:17 +00002427 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002428
Douglas Gregor20093b42009-12-09 23:02:17 +00002429 case SK_ConversionSequence:
2430 delete ICS;
2431 }
2432}
2433
Douglas Gregorb70cf442010-03-26 20:14:36 +00002434bool InitializationSequence::isDirectReferenceBinding() const {
Sebastian Redl3b802322011-07-14 19:07:55 +00002435 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
Douglas Gregorb70cf442010-03-26 20:14:36 +00002436}
2437
2438bool InitializationSequence::isAmbiguous() const {
Sebastian Redld695d6b2011-06-05 13:59:05 +00002439 if (!Failed())
Douglas Gregorb70cf442010-03-26 20:14:36 +00002440 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002441
Douglas Gregorb70cf442010-03-26 20:14:36 +00002442 switch (getFailureKind()) {
2443 case FK_TooManyInitsForReference:
2444 case FK_ArrayNeedsInitList:
2445 case FK_ArrayNeedsInitListOrStringLiteral:
2446 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2447 case FK_NonConstLValueReferenceBindingToTemporary:
2448 case FK_NonConstLValueReferenceBindingToUnrelated:
2449 case FK_RValueReferenceBindingToLValue:
2450 case FK_ReferenceInitDropsQualifiers:
2451 case FK_ReferenceInitFailed:
2452 case FK_ConversionFailed:
John Wiegley429bb272011-04-08 18:41:53 +00002453 case FK_ConversionFromPropertyFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002454 case FK_TooManyInitsForScalar:
2455 case FK_ReferenceBindingToInitList:
2456 case FK_InitListBadDestinationType:
2457 case FK_DefaultInitOfConst:
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002458 case FK_Incomplete:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002459 case FK_ArrayTypeMismatch:
2460 case FK_NonConstantArrayInit:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002461 case FK_ListInitializationFailed:
John McCall73076432012-01-05 00:13:19 +00002462 case FK_VariableLengthArrayHasInitializer:
John McCall5acb0c92011-10-17 18:40:02 +00002463 case FK_PlaceholderType:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002464 case FK_InitListElementCopyFailure:
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002465 case FK_ExplicitConstructor:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002466 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002467
Douglas Gregorb70cf442010-03-26 20:14:36 +00002468 case FK_ReferenceInitOverloadFailed:
2469 case FK_UserConversionOverloadFailed:
2470 case FK_ConstructorOverloadFailed:
Sebastian Redlcf15cef2011-12-22 18:58:38 +00002471 case FK_ListConstructorOverloadFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002472 return FailedOverloadResult == OR_Ambiguous;
2473 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002474
David Blaikie7530c032012-01-17 06:56:22 +00002475 llvm_unreachable("Invalid EntityKind!");
Douglas Gregorb70cf442010-03-26 20:14:36 +00002476}
2477
Douglas Gregord6e44a32010-04-16 22:09:46 +00002478bool InitializationSequence::isConstructorInitialization() const {
2479 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2480}
2481
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002482void
2483InitializationSequence
2484::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2485 DeclAccessPair Found,
2486 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002487 Step S;
2488 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2489 S.Type = Function->getType();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002490 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002491 S.Function.Function = Function;
John McCall6bb80172010-03-30 21:47:33 +00002492 S.Function.FoundDecl = Found;
Douglas Gregor20093b42009-12-09 23:02:17 +00002493 Steps.push_back(S);
2494}
2495
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002496void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00002497 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002498 Step S;
John McCall5baba9d2010-08-25 10:28:54 +00002499 switch (VK) {
2500 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2501 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2502 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002503 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002504 S.Type = BaseType;
2505 Steps.push_back(S);
2506}
2507
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002508void InitializationSequence::AddReferenceBindingStep(QualType T,
Douglas Gregor20093b42009-12-09 23:02:17 +00002509 bool BindingTemporary) {
2510 Step S;
2511 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2512 S.Type = T;
2513 Steps.push_back(S);
2514}
2515
Douglas Gregor523d46a2010-04-18 07:40:54 +00002516void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2517 Step S;
2518 S.Kind = SK_ExtraneousCopyToTemporary;
2519 S.Type = T;
2520 Steps.push_back(S);
2521}
2522
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002523void
2524InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2525 DeclAccessPair FoundDecl,
2526 QualType T,
2527 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002528 Step S;
2529 S.Kind = SK_UserConversion;
Eli Friedman03981012009-12-11 02:42:07 +00002530 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002531 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002532 S.Function.Function = Function;
2533 S.Function.FoundDecl = FoundDecl;
Douglas Gregor20093b42009-12-09 23:02:17 +00002534 Steps.push_back(S);
2535}
2536
2537void InitializationSequence::AddQualificationConversionStep(QualType Ty,
John McCall5baba9d2010-08-25 10:28:54 +00002538 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002539 Step S;
John McCall38a4ffe2010-08-26 16:36:35 +00002540 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
John McCall5baba9d2010-08-25 10:28:54 +00002541 switch (VK) {
2542 case VK_RValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002543 S.Kind = SK_QualificationConversionRValue;
2544 break;
John McCall5baba9d2010-08-25 10:28:54 +00002545 case VK_XValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002546 S.Kind = SK_QualificationConversionXValue;
2547 break;
John McCall5baba9d2010-08-25 10:28:54 +00002548 case VK_LValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002549 S.Kind = SK_QualificationConversionLValue;
2550 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002551 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002552 S.Type = Ty;
2553 Steps.push_back(S);
2554}
2555
2556void InitializationSequence::AddConversionSequenceStep(
2557 const ImplicitConversionSequence &ICS,
2558 QualType T) {
2559 Step S;
2560 S.Kind = SK_ConversionSequence;
2561 S.Type = T;
2562 S.ICS = new ImplicitConversionSequence(ICS);
2563 Steps.push_back(S);
2564}
2565
Douglas Gregord87b61f2009-12-10 17:56:55 +00002566void InitializationSequence::AddListInitializationStep(QualType T) {
2567 Step S;
2568 S.Kind = SK_ListInitialization;
2569 S.Type = T;
2570 Steps.push_back(S);
2571}
2572
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002573void
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002574InitializationSequence
2575::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2576 AccessSpecifier Access,
2577 QualType T,
Sebastian Redl10f04a62011-12-22 14:44:04 +00002578 bool HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002579 bool FromInitList, bool AsInitList) {
Douglas Gregor51c56d62009-12-14 20:49:26 +00002580 Step S;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002581 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall
2582 : SK_ConstructorInitialization;
Douglas Gregor51c56d62009-12-14 20:49:26 +00002583 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002584 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002585 S.Function.Function = Constructor;
2586 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
Douglas Gregor51c56d62009-12-14 20:49:26 +00002587 Steps.push_back(S);
2588}
2589
Douglas Gregor71d17402009-12-15 00:01:57 +00002590void InitializationSequence::AddZeroInitializationStep(QualType T) {
2591 Step S;
2592 S.Kind = SK_ZeroInitialization;
2593 S.Type = T;
2594 Steps.push_back(S);
2595}
2596
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002597void InitializationSequence::AddCAssignmentStep(QualType T) {
2598 Step S;
2599 S.Kind = SK_CAssignment;
2600 S.Type = T;
2601 Steps.push_back(S);
2602}
2603
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002604void InitializationSequence::AddStringInitStep(QualType T) {
2605 Step S;
2606 S.Kind = SK_StringInit;
2607 S.Type = T;
2608 Steps.push_back(S);
2609}
2610
Douglas Gregor569c3162010-08-07 11:51:51 +00002611void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2612 Step S;
2613 S.Kind = SK_ObjCObjectConversion;
2614 S.Type = T;
2615 Steps.push_back(S);
2616}
2617
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002618void InitializationSequence::AddArrayInitStep(QualType T) {
2619 Step S;
2620 S.Kind = SK_ArrayInit;
2621 S.Type = T;
2622 Steps.push_back(S);
2623}
2624
Richard Smith0f163e92012-02-15 22:38:09 +00002625void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2626 Step S;
2627 S.Kind = SK_ParenthesizedArrayInit;
2628 S.Type = T;
2629 Steps.push_back(S);
2630}
2631
John McCallf85e1932011-06-15 23:02:42 +00002632void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2633 bool shouldCopy) {
2634 Step s;
2635 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2636 : SK_PassByIndirectRestore);
2637 s.Type = type;
2638 Steps.push_back(s);
2639}
2640
2641void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2642 Step S;
2643 S.Kind = SK_ProduceObjCObject;
2644 S.Type = T;
2645 Steps.push_back(S);
2646}
2647
Sebastian Redl2b916b82012-01-17 22:49:42 +00002648void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2649 Step S;
2650 S.Kind = SK_StdInitializerList;
2651 S.Type = T;
2652 Steps.push_back(S);
2653}
2654
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002655void InitializationSequence::RewrapReferenceInitList(QualType T,
2656 InitListExpr *Syntactic) {
2657 assert(Syntactic->getNumInits() == 1 &&
2658 "Can only rewrap trivial init lists.");
2659 Step S;
2660 S.Kind = SK_UnwrapInitList;
2661 S.Type = Syntactic->getInit(0)->getType();
2662 Steps.insert(Steps.begin(), S);
2663
2664 S.Kind = SK_RewrapInitList;
2665 S.Type = T;
2666 S.WrappingSyntacticList = Syntactic;
2667 Steps.push_back(S);
2668}
2669
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002670void InitializationSequence::SetOverloadFailure(FailureKind Failure,
Douglas Gregor20093b42009-12-09 23:02:17 +00002671 OverloadingResult Result) {
Sebastian Redl7491c492011-06-05 13:59:11 +00002672 setSequenceKind(FailedSequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00002673 this->Failure = Failure;
2674 this->FailedOverloadResult = Result;
2675}
2676
2677//===----------------------------------------------------------------------===//
2678// Attempt initialization
2679//===----------------------------------------------------------------------===//
2680
John McCallf85e1932011-06-15 23:02:42 +00002681static void MaybeProduceObjCObject(Sema &S,
2682 InitializationSequence &Sequence,
2683 const InitializedEntity &Entity) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002684 if (!S.getLangOpts().ObjCAutoRefCount) return;
John McCallf85e1932011-06-15 23:02:42 +00002685
2686 /// When initializing a parameter, produce the value if it's marked
2687 /// __attribute__((ns_consumed)).
2688 if (Entity.getKind() == InitializedEntity::EK_Parameter) {
2689 if (!Entity.isParameterConsumed())
2690 return;
2691
2692 assert(Entity.getType()->isObjCRetainableType() &&
2693 "consuming an object of unretainable type?");
2694 Sequence.AddProduceObjCObjectStep(Entity.getType());
2695
2696 /// When initializing a return value, if the return type is a
2697 /// retainable type, then returns need to immediately retain the
2698 /// object. If an autorelease is required, it will be done at the
2699 /// last instant.
2700 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
2701 if (!Entity.getType()->isObjCRetainableType())
2702 return;
2703
2704 Sequence.AddProduceObjCObjectStep(Entity.getType());
2705 }
2706}
2707
Richard Smithf4bb8d02012-07-05 08:39:21 +00002708/// \brief When initializing from init list via constructor, handle
2709/// initialization of an object of type std::initializer_list<T>.
Sebastian Redl10f04a62011-12-22 14:44:04 +00002710///
Richard Smithf4bb8d02012-07-05 08:39:21 +00002711/// \return true if we have handled initialization of an object of type
2712/// std::initializer_list<T>, false otherwise.
2713static bool TryInitializerListConstruction(Sema &S,
2714 InitListExpr *List,
2715 QualType DestType,
2716 InitializationSequence &Sequence) {
2717 QualType E;
2718 if (!S.isStdInitializerList(DestType, &E))
Richard Smith1d0c9a82012-02-14 21:14:13 +00002719 return false;
2720
Richard Smithf4bb8d02012-07-05 08:39:21 +00002721 // Check that each individual element can be copy-constructed. But since we
2722 // have no place to store further information, we'll recalculate everything
2723 // later.
2724 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
2725 S.Context.getConstantArrayType(E,
2726 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
2727 List->getNumInits()),
2728 ArrayType::Normal, 0));
2729 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context,
2730 0, HiddenArray);
2731 for (unsigned i = 0, n = List->getNumInits(); i < n; ++i) {
2732 Element.setElementIndex(i);
2733 if (!S.CanPerformCopyInitialization(Element, List->getInit(i))) {
2734 Sequence.SetFailed(
2735 InitializationSequence::FK_InitListElementCopyFailure);
Sebastian Redl10f04a62011-12-22 14:44:04 +00002736 return true;
2737 }
2738 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00002739 Sequence.AddStdInitializerListConstructionStep(DestType);
2740 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002741}
2742
Sebastian Redl96715b22012-02-04 21:27:39 +00002743static OverloadingResult
2744ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
2745 Expr **Args, unsigned NumArgs,
2746 OverloadCandidateSet &CandidateSet,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002747 ArrayRef<NamedDecl *> Ctors,
Sebastian Redl96715b22012-02-04 21:27:39 +00002748 OverloadCandidateSet::iterator &Best,
2749 bool CopyInitializing, bool AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00002750 bool OnlyListConstructors, bool InitListSyntax) {
Sebastian Redl96715b22012-02-04 21:27:39 +00002751 CandidateSet.clear();
2752
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002753 for (ArrayRef<NamedDecl *>::iterator
2754 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
Sebastian Redl96715b22012-02-04 21:27:39 +00002755 NamedDecl *D = *Con;
2756 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
2757 bool SuppressUserConversions = false;
2758
2759 // Find the constructor (which may be a template).
2760 CXXConstructorDecl *Constructor = 0;
2761 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
2762 if (ConstructorTmpl)
2763 Constructor = cast<CXXConstructorDecl>(
2764 ConstructorTmpl->getTemplatedDecl());
2765 else {
2766 Constructor = cast<CXXConstructorDecl>(D);
2767
2768 // If we're performing copy initialization using a copy constructor, we
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00002769 // suppress user-defined conversions on the arguments. We do the same for
2770 // move constructors.
2771 if ((CopyInitializing || (InitListSyntax && NumArgs == 1)) &&
2772 Constructor->isCopyOrMoveConstructor())
Sebastian Redl96715b22012-02-04 21:27:39 +00002773 SuppressUserConversions = true;
2774 }
2775
2776 if (!Constructor->isInvalidDecl() &&
2777 (AllowExplicit || !Constructor->isExplicit()) &&
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002778 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
Sebastian Redl96715b22012-02-04 21:27:39 +00002779 if (ConstructorTmpl)
2780 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
2781 /*ExplicitArgs*/ 0,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00002782 llvm::makeArrayRef(Args, NumArgs),
2783 CandidateSet, SuppressUserConversions);
Douglas Gregored878af2012-02-24 23:56:31 +00002784 else {
2785 // C++ [over.match.copy]p1:
2786 // - When initializing a temporary to be bound to the first parameter
2787 // of a constructor that takes a reference to possibly cv-qualified
2788 // T as its first argument, called with a single argument in the
2789 // context of direct-initialization, explicit conversion functions
2790 // are also considered.
2791 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
2792 NumArgs == 1 &&
2793 Constructor->isCopyOrMoveConstructor();
Sebastian Redl96715b22012-02-04 21:27:39 +00002794 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00002795 llvm::makeArrayRef(Args, NumArgs), CandidateSet,
Douglas Gregored878af2012-02-24 23:56:31 +00002796 SuppressUserConversions,
2797 /*PartialOverloading=*/false,
2798 /*AllowExplicit=*/AllowExplicitConv);
2799 }
Sebastian Redl96715b22012-02-04 21:27:39 +00002800 }
2801 }
2802
2803 // Perform overload resolution and return the result.
2804 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
2805}
2806
Sebastian Redl10f04a62011-12-22 14:44:04 +00002807/// \brief Attempt initialization by constructor (C++ [dcl.init]), which
2808/// enumerates the constructors of the initialized entity and performs overload
2809/// resolution to select the best.
Sebastian Redl08ae3692012-02-04 21:27:33 +00002810/// If InitListSyntax is true, this is list-initialization of a non-aggregate
Sebastian Redl10f04a62011-12-22 14:44:04 +00002811/// class type.
2812static void TryConstructorInitialization(Sema &S,
2813 const InitializedEntity &Entity,
2814 const InitializationKind &Kind,
2815 Expr **Args, unsigned NumArgs,
2816 QualType DestType,
2817 InitializationSequence &Sequence,
Sebastian Redl08ae3692012-02-04 21:27:33 +00002818 bool InitListSyntax = false) {
2819 assert((!InitListSyntax || (NumArgs == 1 && isa<InitListExpr>(Args[0]))) &&
2820 "InitListSyntax must come with a single initializer list argument.");
2821
Sebastian Redl10f04a62011-12-22 14:44:04 +00002822 // The type we're constructing needs to be complete.
2823 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00002824 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redl96715b22012-02-04 21:27:39 +00002825 return;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002826 }
2827
2828 const RecordType *DestRecordType = DestType->getAs<RecordType>();
2829 assert(DestRecordType && "Constructor initialization requires record type");
2830 CXXRecordDecl *DestRecordDecl
2831 = cast<CXXRecordDecl>(DestRecordType->getDecl());
2832
Sebastian Redl96715b22012-02-04 21:27:39 +00002833 // Build the candidate set directly in the initialization sequence
2834 // structure, so that it will persist if we fail.
2835 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
2836
2837 // Determine whether we are allowed to call explicit constructors or
2838 // explicit conversion operators.
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002839 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002840 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
Sebastian Redl08ae3692012-02-04 21:27:33 +00002841
Sebastian Redl10f04a62011-12-22 14:44:04 +00002842 // - Otherwise, if T is a class type, constructors are considered. The
2843 // applicable constructors are enumerated, and the best one is chosen
2844 // through overload resolution.
David Blaikie3bc93e32012-12-19 00:45:41 +00002845 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002846 // The container holding the constructors can under certain conditions
2847 // be changed while iterating (e.g. because of deserialization).
2848 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00002849 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Sebastian Redl10f04a62011-12-22 14:44:04 +00002850
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002851 OverloadingResult Result = OR_No_Viable_Function;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002852 OverloadCandidateSet::iterator Best;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002853 bool AsInitializerList = false;
2854
2855 // C++11 [over.match.list]p1:
2856 // When objects of non-aggregate type T are list-initialized, overload
2857 // resolution selects the constructor in two phases:
2858 // - Initially, the candidate functions are the initializer-list
2859 // constructors of the class T and the argument list consists of the
2860 // initializer list as a single argument.
2861 if (InitListSyntax) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00002862 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002863 AsInitializerList = true;
Richard Smithf4bb8d02012-07-05 08:39:21 +00002864
2865 // If the initializer list has no elements and T has a default constructor,
2866 // the first phase is omitted.
Richard Smithe5411b72012-12-01 02:35:44 +00002867 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
Richard Smithf4bb8d02012-07-05 08:39:21 +00002868 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, NumArgs,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002869 CandidateSet, Ctors, Best,
Richard Smithf4bb8d02012-07-05 08:39:21 +00002870 CopyInitialization, AllowExplicit,
2871 /*OnlyListConstructor=*/true,
2872 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002873
2874 // Time to unwrap the init list.
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002875 Args = ILE->getInits();
2876 NumArgs = ILE->getNumInits();
2877 }
2878
2879 // C++11 [over.match.list]p1:
2880 // - If no viable initializer-list constructor is found, overload resolution
2881 // is performed again, where the candidate functions are all the
Richard Smithf4bb8d02012-07-05 08:39:21 +00002882 // constructors of the class T and the argument list consists of the
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002883 // elements of the initializer list.
2884 if (Result == OR_No_Viable_Function) {
2885 AsInitializerList = false;
2886 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, NumArgs,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00002887 CandidateSet, Ctors, Best,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002888 CopyInitialization, AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00002889 /*OnlyListConstructors=*/false,
2890 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002891 }
2892 if (Result) {
Sebastian Redl08ae3692012-02-04 21:27:33 +00002893 Sequence.SetOverloadFailure(InitListSyntax ?
Sebastian Redlcf15cef2011-12-22 18:58:38 +00002894 InitializationSequence::FK_ListConstructorOverloadFailed :
2895 InitializationSequence::FK_ConstructorOverloadFailed,
Sebastian Redl10f04a62011-12-22 14:44:04 +00002896 Result);
2897 return;
2898 }
2899
Richard Smithf4bb8d02012-07-05 08:39:21 +00002900 // C++11 [dcl.init]p6:
Sebastian Redl10f04a62011-12-22 14:44:04 +00002901 // If a program calls for the default initialization of an object
2902 // of a const-qualified type T, T shall be a class type with a
2903 // user-provided default constructor.
2904 if (Kind.getKind() == InitializationKind::IK_Default &&
2905 Entity.getType().isConstQualified() &&
Aaron Ballman51217812012-07-31 22:40:31 +00002906 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00002907 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
2908 return;
2909 }
2910
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002911 // C++11 [over.match.list]p1:
2912 // In copy-list-initialization, if an explicit constructor is chosen, the
2913 // initializer is ill-formed.
2914 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
2915 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
2916 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
2917 return;
2918 }
2919
Sebastian Redl10f04a62011-12-22 14:44:04 +00002920 // Add the constructor initialization step. Any cv-qualification conversion is
2921 // subsumed by the initialization.
2922 bool HadMultipleCandidates = (CandidateSet.size() > 1);
Sebastian Redl10f04a62011-12-22 14:44:04 +00002923 Sequence.AddConstructorInitializationStep(CtorDecl,
2924 Best->FoundDecl.getAccess(),
2925 DestType, HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002926 InitListSyntax, AsInitializerList);
Sebastian Redl10f04a62011-12-22 14:44:04 +00002927}
2928
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002929static bool
2930ResolveOverloadedFunctionForReferenceBinding(Sema &S,
2931 Expr *Initializer,
2932 QualType &SourceType,
2933 QualType &UnqualifiedSourceType,
2934 QualType UnqualifiedTargetType,
2935 InitializationSequence &Sequence) {
2936 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
2937 S.Context.OverloadTy) {
2938 DeclAccessPair Found;
2939 bool HadMultipleCandidates = false;
2940 if (FunctionDecl *Fn
2941 = S.ResolveAddressOfOverloadedFunction(Initializer,
2942 UnqualifiedTargetType,
2943 false, Found,
2944 &HadMultipleCandidates)) {
2945 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
2946 HadMultipleCandidates);
2947 SourceType = Fn->getType();
2948 UnqualifiedSourceType = SourceType.getUnqualifiedType();
2949 } else if (!UnqualifiedTargetType->isRecordType()) {
2950 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
2951 return true;
2952 }
2953 }
2954 return false;
2955}
2956
2957static void TryReferenceInitializationCore(Sema &S,
2958 const InitializedEntity &Entity,
2959 const InitializationKind &Kind,
2960 Expr *Initializer,
2961 QualType cv1T1, QualType T1,
2962 Qualifiers T1Quals,
2963 QualType cv2T2, QualType T2,
2964 Qualifiers T2Quals,
2965 InitializationSequence &Sequence);
2966
Richard Smithf4bb8d02012-07-05 08:39:21 +00002967static void TryValueInitialization(Sema &S,
2968 const InitializedEntity &Entity,
2969 const InitializationKind &Kind,
2970 InitializationSequence &Sequence,
2971 InitListExpr *InitList = 0);
2972
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002973static void TryListInitialization(Sema &S,
2974 const InitializedEntity &Entity,
2975 const InitializationKind &Kind,
2976 InitListExpr *InitList,
2977 InitializationSequence &Sequence);
2978
2979/// \brief Attempt list initialization of a reference.
2980static void TryReferenceListInitialization(Sema &S,
2981 const InitializedEntity &Entity,
2982 const InitializationKind &Kind,
2983 InitListExpr *InitList,
2984 InitializationSequence &Sequence)
2985{
2986 // First, catch C++03 where this isn't possible.
Richard Smith80ad52f2013-01-02 11:42:31 +00002987 if (!S.getLangOpts().CPlusPlus11) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002988 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
2989 return;
2990 }
2991
2992 QualType DestType = Entity.getType();
2993 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
2994 Qualifiers T1Quals;
2995 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
2996
2997 // Reference initialization via an initializer list works thus:
2998 // If the initializer list consists of a single element that is
2999 // reference-related to the referenced type, bind directly to that element
3000 // (possibly creating temporaries).
3001 // Otherwise, initialize a temporary with the initializer list and
3002 // bind to that.
3003 if (InitList->getNumInits() == 1) {
3004 Expr *Initializer = InitList->getInit(0);
3005 QualType cv2T2 = Initializer->getType();
3006 Qualifiers T2Quals;
3007 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3008
3009 // If this fails, creating a temporary wouldn't work either.
3010 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3011 T1, Sequence))
3012 return;
3013
3014 SourceLocation DeclLoc = Initializer->getLocStart();
3015 bool dummy1, dummy2, dummy3;
3016 Sema::ReferenceCompareResult RefRelationship
3017 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3018 dummy2, dummy3);
3019 if (RefRelationship >= Sema::Ref_Related) {
3020 // Try to bind the reference here.
3021 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3022 T1Quals, cv2T2, T2, T2Quals, Sequence);
3023 if (Sequence)
3024 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3025 return;
3026 }
Richard Smith02d65ee2013-01-15 07:58:29 +00003027
3028 // Update the initializer if we've resolved an overloaded function.
3029 if (Sequence.step_begin() != Sequence.step_end())
3030 Sequence.RewrapReferenceInitList(cv1T1, InitList);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003031 }
3032
3033 // Not reference-related. Create a temporary and bind to that.
3034 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3035
3036 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3037 if (Sequence) {
3038 if (DestType->isRValueReferenceType() ||
3039 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3040 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3041 else
3042 Sequence.SetFailed(
3043 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3044 }
3045}
3046
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003047/// \brief Attempt list initialization (C++0x [dcl.init.list])
3048static void TryListInitialization(Sema &S,
3049 const InitializedEntity &Entity,
3050 const InitializationKind &Kind,
3051 InitListExpr *InitList,
3052 InitializationSequence &Sequence) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003053 QualType DestType = Entity.getType();
3054
Sebastian Redl14b0c192011-09-24 17:48:00 +00003055 // C++ doesn't allow scalar initialization with more than one argument.
3056 // But C99 complex numbers are scalars and it makes sense there.
David Blaikie4e4d0842012-03-11 07:00:24 +00003057 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
Sebastian Redl14b0c192011-09-24 17:48:00 +00003058 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3059 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3060 return;
3061 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00003062 if (DestType->isReferenceType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003063 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003064 return;
Sebastian Redl14b0c192011-09-24 17:48:00 +00003065 }
Sebastian Redld2231c92012-02-19 12:27:43 +00003066 if (DestType->isRecordType()) {
Douglas Gregord10099e2012-05-04 16:32:21 +00003067 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003068 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redld2231c92012-02-19 12:27:43 +00003069 return;
3070 }
3071
Richard Smithf4bb8d02012-07-05 08:39:21 +00003072 // C++11 [dcl.init.list]p3:
3073 // - If T is an aggregate, aggregate initialization is performed.
Sebastian Redld2231c92012-02-19 12:27:43 +00003074 if (!DestType->isAggregateType()) {
Richard Smith80ad52f2013-01-02 11:42:31 +00003075 if (S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003076 // - Otherwise, if the initializer list has no elements and T is a
3077 // class type with a default constructor, the object is
3078 // value-initialized.
3079 if (InitList->getNumInits() == 0) {
3080 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
Richard Smithe5411b72012-12-01 02:35:44 +00003081 if (RD->hasDefaultConstructor()) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003082 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3083 return;
3084 }
3085 }
3086
3087 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3088 // an initializer_list object constructed [...]
3089 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3090 return;
3091
3092 // - Otherwise, if T is a class type, constructors are considered.
Sebastian Redld2231c92012-02-19 12:27:43 +00003093 Expr *Arg = InitList;
Richard Smithf4bb8d02012-07-05 08:39:21 +00003094 TryConstructorInitialization(S, Entity, Kind, &Arg, 1, DestType,
3095 Sequence, /*InitListSyntax*/true);
Sebastian Redld2231c92012-02-19 12:27:43 +00003096 } else
3097 Sequence.SetFailed(
3098 InitializationSequence::FK_InitListBadDestinationType);
3099 return;
3100 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003101 }
3102
Sebastian Redl14b0c192011-09-24 17:48:00 +00003103 InitListChecker CheckInitList(S, Entity, InitList,
Sebastian Redlc2235182011-10-16 18:19:28 +00003104 DestType, /*VerifyOnly=*/true,
Sebastian Redl168319c2012-02-12 16:37:24 +00003105 Kind.getKind() != InitializationKind::IK_DirectList ||
Richard Smith80ad52f2013-01-02 11:42:31 +00003106 !S.getLangOpts().CPlusPlus11);
Sebastian Redl14b0c192011-09-24 17:48:00 +00003107 if (CheckInitList.HadError()) {
3108 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3109 return;
3110 }
3111
3112 // Add the list initialization step with the built init list.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003113 Sequence.AddListInitializationStep(DestType);
3114}
Douglas Gregor20093b42009-12-09 23:02:17 +00003115
3116/// \brief Try a reference initialization that involves calling a conversion
3117/// function.
Douglas Gregor20093b42009-12-09 23:02:17 +00003118static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3119 const InitializedEntity &Entity,
3120 const InitializationKind &Kind,
Douglas Gregored878af2012-02-24 23:56:31 +00003121 Expr *Initializer,
3122 bool AllowRValues,
Douglas Gregor20093b42009-12-09 23:02:17 +00003123 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003124 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003125 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3126 QualType T1 = cv1T1.getUnqualifiedType();
3127 QualType cv2T2 = Initializer->getType();
3128 QualType T2 = cv2T2.getUnqualifiedType();
3129
3130 bool DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003131 bool ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003132 bool ObjCLifetimeConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003133 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
Douglas Gregor569c3162010-08-07 11:51:51 +00003134 T1, T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003135 ObjCConversion,
3136 ObjCLifetimeConversion) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003137 "Must have incompatible references when binding via conversion");
Chandler Carruth60cfcec2009-12-13 01:37:04 +00003138 (void)DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003139 (void)ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003140 (void)ObjCLifetimeConversion;
3141
Douglas Gregor20093b42009-12-09 23:02:17 +00003142 // Build the candidate set directly in the initialization sequence
3143 // structure, so that it will persist if we fail.
3144 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3145 CandidateSet.clear();
3146
3147 // Determine whether we are allowed to call explicit constructors or
3148 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003149 bool AllowExplicit = Kind.AllowExplicit();
Douglas Gregored878af2012-02-24 23:56:31 +00003150 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctions();
3151
Douglas Gregor20093b42009-12-09 23:02:17 +00003152 const RecordType *T1RecordType = 0;
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003153 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3154 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003155 // The type we're converting to is a class type. Enumerate its constructors
3156 // to see if there is a suitable conversion.
3157 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
John McCall572fc622010-08-17 07:23:57 +00003158
David Blaikie3bc93e32012-12-19 00:45:41 +00003159 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003160 // The container holding the constructors can under certain conditions
3161 // be changed while iterating (e.g. because of deserialization).
3162 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003163 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003164 for (SmallVector<NamedDecl*, 16>::iterator
3165 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3166 NamedDecl *D = *CI;
John McCall9aa472c2010-03-19 07:35:19 +00003167 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3168
Douglas Gregor20093b42009-12-09 23:02:17 +00003169 // Find the constructor (which may be a template).
3170 CXXConstructorDecl *Constructor = 0;
John McCall9aa472c2010-03-19 07:35:19 +00003171 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor20093b42009-12-09 23:02:17 +00003172 if (ConstructorTmpl)
3173 Constructor = cast<CXXConstructorDecl>(
3174 ConstructorTmpl->getTemplatedDecl());
3175 else
John McCall9aa472c2010-03-19 07:35:19 +00003176 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003177
Douglas Gregor20093b42009-12-09 23:02:17 +00003178 if (!Constructor->isInvalidDecl() &&
3179 Constructor->isConvertingConstructor(AllowExplicit)) {
3180 if (ConstructorTmpl)
John McCall9aa472c2010-03-19 07:35:19 +00003181 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
John McCall86820f52010-01-26 01:37:31 +00003182 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003183 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003184 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003185 else
John McCall9aa472c2010-03-19 07:35:19 +00003186 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003187 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003188 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003189 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003190 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003191 }
John McCall572fc622010-08-17 07:23:57 +00003192 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3193 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003194
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003195 const RecordType *T2RecordType = 0;
3196 if ((T2RecordType = T2->getAs<RecordType>()) &&
3197 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003198 // The type we're converting from is a class type, enumerate its conversion
3199 // functions.
3200 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3201
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00003202 std::pair<CXXRecordDecl::conversion_iterator,
3203 CXXRecordDecl::conversion_iterator>
3204 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3205 for (CXXRecordDecl::conversion_iterator
3206 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003207 NamedDecl *D = *I;
3208 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3209 if (isa<UsingShadowDecl>(D))
3210 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003211
Douglas Gregor20093b42009-12-09 23:02:17 +00003212 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3213 CXXConversionDecl *Conv;
3214 if (ConvTemplate)
3215 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3216 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003217 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003218
Douglas Gregor20093b42009-12-09 23:02:17 +00003219 // If the conversion function doesn't return a reference type,
3220 // it can't be considered for this conversion unless we're allowed to
3221 // consider rvalues.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003222 // FIXME: Do we need to make sure that we only consider conversion
3223 // candidates with reference-compatible results? That might be needed to
Douglas Gregor20093b42009-12-09 23:02:17 +00003224 // break recursion.
Douglas Gregored878af2012-02-24 23:56:31 +00003225 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003226 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3227 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00003228 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00003229 ActingDC, Initializer,
Douglas Gregor564cb062011-01-21 00:27:08 +00003230 DestType, CandidateSet);
Douglas Gregor20093b42009-12-09 23:02:17 +00003231 else
John McCall9aa472c2010-03-19 07:35:19 +00003232 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Douglas Gregor564cb062011-01-21 00:27:08 +00003233 Initializer, DestType, CandidateSet);
Douglas Gregor20093b42009-12-09 23:02:17 +00003234 }
3235 }
3236 }
John McCall572fc622010-08-17 07:23:57 +00003237 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3238 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003239
Douglas Gregor20093b42009-12-09 23:02:17 +00003240 SourceLocation DeclLoc = Initializer->getLocStart();
3241
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003242 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor20093b42009-12-09 23:02:17 +00003243 OverloadCandidateSet::iterator Best;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003244 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00003245 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
Douglas Gregor20093b42009-12-09 23:02:17 +00003246 return Result;
Eli Friedman03981012009-12-11 02:42:07 +00003247
Douglas Gregor20093b42009-12-09 23:02:17 +00003248 FunctionDecl *Function = Best->Function;
Eli Friedman03981012009-12-11 02:42:07 +00003249
Chandler Carruth25ca4212011-02-25 19:41:05 +00003250 // This is the overload that will actually be used for the initialization, so
3251 // mark it as used.
Eli Friedman5f2987c2012-02-02 03:46:19 +00003252 S.MarkFunctionReferenced(DeclLoc, Function);
Chandler Carruth25ca4212011-02-25 19:41:05 +00003253
Eli Friedman03981012009-12-11 02:42:07 +00003254 // Compute the returned type of the conversion.
Douglas Gregor20093b42009-12-09 23:02:17 +00003255 if (isa<CXXConversionDecl>(Function))
3256 T2 = Function->getResultType();
3257 else
3258 T2 = cv1T1;
Eli Friedman03981012009-12-11 02:42:07 +00003259
3260 // Add the user-defined conversion step.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003261 bool HadMultipleCandidates = (CandidateSet.size() > 1);
John McCall9aa472c2010-03-19 07:35:19 +00003262 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003263 T2.getNonLValueExprType(S.Context),
3264 HadMultipleCandidates);
Eli Friedman03981012009-12-11 02:42:07 +00003265
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003266 // Determine whether we need to perform derived-to-base or
Eli Friedman03981012009-12-11 02:42:07 +00003267 // cv-qualification adjustments.
John McCall5baba9d2010-08-25 10:28:54 +00003268 ExprValueKind VK = VK_RValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003269 if (T2->isLValueReferenceType())
John McCall5baba9d2010-08-25 10:28:54 +00003270 VK = VK_LValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003271 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
John McCall5baba9d2010-08-25 10:28:54 +00003272 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003273
Douglas Gregor20093b42009-12-09 23:02:17 +00003274 bool NewDerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003275 bool NewObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003276 bool NewObjCLifetimeConversion = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00003277 Sema::ReferenceCompareResult NewRefRelationship
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003278 = S.CompareReferenceRelationship(DeclLoc, T1,
Douglas Gregor63982352010-07-13 18:40:04 +00003279 T2.getNonLValueExprType(S.Context),
John McCallf85e1932011-06-15 23:02:42 +00003280 NewDerivedToBase, NewObjCConversion,
3281 NewObjCLifetimeConversion);
Douglas Gregora1a9f032010-03-07 23:17:44 +00003282 if (NewRefRelationship == Sema::Ref_Incompatible) {
3283 // If the type we've converted to is not reference-related to the
3284 // type we're looking for, then there is another conversion step
3285 // we need to perform to produce a temporary of the right type
3286 // that we'll be binding to.
3287 ImplicitConversionSequence ICS;
3288 ICS.setStandard();
3289 ICS.Standard = Best->FinalConversion;
3290 T2 = ICS.Standard.getToType(2);
3291 Sequence.AddConversionSequenceStep(ICS, T2);
3292 } else if (NewDerivedToBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00003293 Sequence.AddDerivedToBaseCastStep(
3294 S.Context.getQualifiedType(T1,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003295 T2.getNonReferenceType().getQualifiers()),
John McCall5baba9d2010-08-25 10:28:54 +00003296 VK);
Douglas Gregor569c3162010-08-07 11:51:51 +00003297 else if (NewObjCConversion)
3298 Sequence.AddObjCObjectConversionStep(
3299 S.Context.getQualifiedType(T1,
3300 T2.getNonReferenceType().getQualifiers()));
3301
Douglas Gregor20093b42009-12-09 23:02:17 +00003302 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
John McCall5baba9d2010-08-25 10:28:54 +00003303 Sequence.AddQualificationConversionStep(cv1T1, VK);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003304
Douglas Gregor20093b42009-12-09 23:02:17 +00003305 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3306 return OR_Success;
3307}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003308
Richard Smith83da2e72011-10-19 16:55:56 +00003309static void CheckCXX98CompatAccessibleCopy(Sema &S,
3310 const InitializedEntity &Entity,
3311 Expr *CurInitExpr);
3312
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003313/// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3314static void TryReferenceInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003315 const InitializedEntity &Entity,
3316 const InitializationKind &Kind,
3317 Expr *Initializer,
3318 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003319 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003320 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003321 Qualifiers T1Quals;
3322 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
Douglas Gregor20093b42009-12-09 23:02:17 +00003323 QualType cv2T2 = Initializer->getType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003324 Qualifiers T2Quals;
3325 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003326
Douglas Gregor20093b42009-12-09 23:02:17 +00003327 // If the initializer is the address of an overloaded function, try
3328 // to resolve the overloaded function. If all goes well, T2 is the
3329 // type of the resulting function.
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003330 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3331 T1, Sequence))
3332 return;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003333
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003334 // Delegate everything else to a subfunction.
3335 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3336 T1Quals, cv2T2, T2, T2Quals, Sequence);
3337}
3338
3339/// \brief Reference initialization without resolving overloaded functions.
3340static void TryReferenceInitializationCore(Sema &S,
3341 const InitializedEntity &Entity,
3342 const InitializationKind &Kind,
3343 Expr *Initializer,
3344 QualType cv1T1, QualType T1,
3345 Qualifiers T1Quals,
3346 QualType cv2T2, QualType T2,
3347 Qualifiers T2Quals,
3348 InitializationSequence &Sequence) {
3349 QualType DestType = Entity.getType();
3350 SourceLocation DeclLoc = Initializer->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00003351 // Compute some basic properties of the types and the initializer.
3352 bool isLValueRef = DestType->isLValueReferenceType();
3353 bool isRValueRef = !isLValueRef;
3354 bool DerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003355 bool ObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003356 bool ObjCLifetimeConversion = false;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003357 Expr::Classification InitCategory = Initializer->Classify(S.Context);
Douglas Gregor20093b42009-12-09 23:02:17 +00003358 Sema::ReferenceCompareResult RefRelationship
Douglas Gregor569c3162010-08-07 11:51:51 +00003359 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003360 ObjCConversion, ObjCLifetimeConversion);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003361
Douglas Gregor20093b42009-12-09 23:02:17 +00003362 // C++0x [dcl.init.ref]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003363 // A reference to type "cv1 T1" is initialized by an expression of type
Douglas Gregor20093b42009-12-09 23:02:17 +00003364 // "cv2 T2" as follows:
3365 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003366 // - If the reference is an lvalue reference and the initializer
Douglas Gregor20093b42009-12-09 23:02:17 +00003367 // expression
Sebastian Redl4680bf22010-06-30 18:13:39 +00003368 // Note the analogous bullet points for rvlaue refs to functions. Because
3369 // there are no function rvalues in C++, rvalue refs to functions are treated
3370 // like lvalue refs.
Douglas Gregor20093b42009-12-09 23:02:17 +00003371 OverloadingResult ConvOvlResult = OR_Success;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003372 bool T1Function = T1->isFunctionType();
3373 if (isLValueRef || T1Function) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003374 if (InitCategory.isLValue() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003375 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003376 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003377 RefRelationship == Sema::Ref_Related))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003378 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
Douglas Gregor20093b42009-12-09 23:02:17 +00003379 // reference-compatible with "cv2 T2," or
3380 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003381 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
Douglas Gregor20093b42009-12-09 23:02:17 +00003382 // bit-field when we're determining whether the reference initialization
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003383 // can occur. However, we do pay attention to whether it is a bit-field
3384 // to decide whether we're actually binding to a temporary created from
3385 // the bit-field.
Douglas Gregor20093b42009-12-09 23:02:17 +00003386 if (DerivedToBase)
3387 Sequence.AddDerivedToBaseCastStep(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003388 S.Context.getQualifiedType(T1, T2Quals),
John McCall5baba9d2010-08-25 10:28:54 +00003389 VK_LValue);
Douglas Gregor569c3162010-08-07 11:51:51 +00003390 else if (ObjCConversion)
3391 Sequence.AddObjCObjectConversionStep(
3392 S.Context.getQualifiedType(T1, T2Quals));
3393
Chandler Carruth5535c382010-01-12 20:32:25 +00003394 if (T1Quals != T2Quals)
John McCall5baba9d2010-08-25 10:28:54 +00003395 Sequence.AddQualificationConversionStep(cv1T1, VK_LValue);
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003396 bool BindingTemporary = T1Quals.hasConst() && !T1Quals.hasVolatile() &&
Anders Carlsson09380262010-01-31 17:18:49 +00003397 (Initializer->getBitField() || Initializer->refersToVectorElement());
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003398 Sequence.AddReferenceBindingStep(cv1T1, BindingTemporary);
Douglas Gregor20093b42009-12-09 23:02:17 +00003399 return;
3400 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003401
3402 // - has a class type (i.e., T2 is a class type), where T1 is not
3403 // reference-related to T2, and can be implicitly converted to an
3404 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3405 // with "cv3 T3" (this conversion is selected by enumerating the
Douglas Gregor20093b42009-12-09 23:02:17 +00003406 // applicable conversion functions (13.3.1.6) and choosing the best
3407 // one through overload resolution (13.3)),
Sebastian Redl4680bf22010-06-30 18:13:39 +00003408 // If we have an rvalue ref to function type here, the rhs must be
3409 // an rvalue.
3410 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3411 (isLValueRef || InitCategory.isRValue())) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003412 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind,
Douglas Gregor20093b42009-12-09 23:02:17 +00003413 Initializer,
Sebastian Redl4680bf22010-06-30 18:13:39 +00003414 /*AllowRValues=*/isRValueRef,
Douglas Gregor20093b42009-12-09 23:02:17 +00003415 Sequence);
3416 if (ConvOvlResult == OR_Success)
3417 return;
John McCall1d318332010-01-12 00:44:57 +00003418 if (ConvOvlResult != OR_No_Viable_Function) {
3419 Sequence.SetOverloadFailure(
3420 InitializationSequence::FK_ReferenceInitOverloadFailed,
3421 ConvOvlResult);
3422 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003423 }
3424 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003425
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003426 // - Otherwise, the reference shall be an lvalue reference to a
Douglas Gregor20093b42009-12-09 23:02:17 +00003427 // non-volatile const type (i.e., cv1 shall be const), or the reference
Douglas Gregor69d83162011-01-20 16:08:06 +00003428 // shall be an rvalue reference.
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003429 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
Douglas Gregor3afb9772010-11-08 15:20:28 +00003430 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3431 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3432 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
Douglas Gregor20093b42009-12-09 23:02:17 +00003433 Sequence.SetOverloadFailure(
3434 InitializationSequence::FK_ReferenceInitOverloadFailed,
3435 ConvOvlResult);
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003436 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003437 Sequence.SetFailed(InitCategory.isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00003438 ? (RefRelationship == Sema::Ref_Related
3439 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3440 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3441 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003442
Douglas Gregor20093b42009-12-09 23:02:17 +00003443 return;
3444 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003445
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003446 // - If the initializer expression
3447 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3448 // "cv1 T1" is reference-compatible with "cv2 T2"
3449 // Note: functions are handled below.
3450 if (!T1Function &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003451 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003452 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003453 RefRelationship == Sema::Ref_Related)) &&
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003454 (InitCategory.isXValue() ||
3455 (InitCategory.isPRValue() && T2->isRecordType()) ||
3456 (InitCategory.isPRValue() && T2->isArrayType()))) {
3457 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3458 if (InitCategory.isPRValue() && T2->isRecordType()) {
Douglas Gregor523d46a2010-04-18 07:40:54 +00003459 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3460 // compiler the freedom to perform a copy here or bind to the
3461 // object, while C++0x requires that we bind directly to the
3462 // object. Hence, we always bind to the object without making an
3463 // extra copy. However, in C++03 requires that we check for the
3464 // presence of a suitable copy constructor:
3465 //
3466 // The constructor that would be used to make the copy shall
3467 // be callable whether or not the copy is actually done.
Richard Smith80ad52f2013-01-02 11:42:31 +00003468 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
Douglas Gregor523d46a2010-04-18 07:40:54 +00003469 Sequence.AddExtraneousCopyToTemporary(cv2T2);
Richard Smith80ad52f2013-01-02 11:42:31 +00003470 else if (S.getLangOpts().CPlusPlus11)
Richard Smith83da2e72011-10-19 16:55:56 +00003471 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
Douglas Gregor20093b42009-12-09 23:02:17 +00003472 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003473
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003474 if (DerivedToBase)
3475 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3476 ValueKind);
3477 else if (ObjCConversion)
3478 Sequence.AddObjCObjectConversionStep(
3479 S.Context.getQualifiedType(T1, T2Quals));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003480
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003481 if (T1Quals != T2Quals)
3482 Sequence.AddQualificationConversionStep(cv1T1, ValueKind);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003483 Sequence.AddReferenceBindingStep(cv1T1,
Peter Collingbourne65bfd682011-11-13 00:51:30 +00003484 /*bindingTemporary=*/InitCategory.isPRValue());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003485 return;
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003486 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003487
3488 // - has a class type (i.e., T2 is a class type), where T1 is not
3489 // reference-related to T2, and can be implicitly converted to an
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003490 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3491 // where "cv1 T1" is reference-compatible with "cv3 T3",
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003492 if (T2->isRecordType()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003493 if (RefRelationship == Sema::Ref_Incompatible) {
3494 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity,
3495 Kind, Initializer,
3496 /*AllowRValues=*/true,
3497 Sequence);
3498 if (ConvOvlResult)
3499 Sequence.SetOverloadFailure(
3500 InitializationSequence::FK_ReferenceInitOverloadFailed,
3501 ConvOvlResult);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003502
Douglas Gregor20093b42009-12-09 23:02:17 +00003503 return;
3504 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003505
Douglas Gregor20093b42009-12-09 23:02:17 +00003506 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3507 return;
3508 }
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003509
3510 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
Douglas Gregor20093b42009-12-09 23:02:17 +00003511 // from the initializer expression using the rules for a non-reference
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003512 // copy initialization (8.5). The reference is then bound to the
Douglas Gregor20093b42009-12-09 23:02:17 +00003513 // temporary. [...]
John McCall369371c2010-06-04 02:29:22 +00003514
Douglas Gregor20093b42009-12-09 23:02:17 +00003515 // Determine whether we are allowed to call explicit constructors or
3516 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003517 bool AllowExplicit = Kind.AllowExplicit();
John McCall369371c2010-06-04 02:29:22 +00003518
3519 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3520
John McCallf85e1932011-06-15 23:02:42 +00003521 ImplicitConversionSequence ICS
3522 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
John McCall369371c2010-06-04 02:29:22 +00003523 /*SuppressUserConversions*/ false,
3524 AllowExplicit,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003525 /*FIXME:InOverloadResolution=*/false,
John McCallf85e1932011-06-15 23:02:42 +00003526 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3527 /*AllowObjCWritebackConversion=*/false);
3528
3529 if (ICS.isBad()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003530 // FIXME: Use the conversion function set stored in ICS to turn
3531 // this into an overloading ambiguity diagnostic. However, we need
3532 // to keep that set as an OverloadCandidateSet rather than as some
3533 // other kind of set.
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003534 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3535 Sequence.SetOverloadFailure(
3536 InitializationSequence::FK_ReferenceInitOverloadFailed,
3537 ConvOvlResult);
Douglas Gregor3afb9772010-11-08 15:20:28 +00003538 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3539 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003540 else
3541 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
Douglas Gregor20093b42009-12-09 23:02:17 +00003542 return;
John McCallf85e1932011-06-15 23:02:42 +00003543 } else {
3544 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003545 }
3546
3547 // [...] If T1 is reference-related to T2, cv1 must be the
3548 // same cv-qualification as, or greater cv-qualification
3549 // than, cv2; otherwise, the program is ill-formed.
Chandler Carruth5535c382010-01-12 20:32:25 +00003550 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3551 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003552 if (RefRelationship == Sema::Ref_Related &&
Chandler Carruth5535c382010-01-12 20:32:25 +00003553 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003554 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3555 return;
3556 }
3557
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003558 // [...] If T1 is reference-related to T2 and the reference is an rvalue
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003559 // reference, the initializer expression shall not be an lvalue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003560 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003561 InitCategory.isLValue()) {
3562 Sequence.SetFailed(
3563 InitializationSequence::FK_RValueReferenceBindingToLValue);
3564 return;
3565 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003566
Douglas Gregor20093b42009-12-09 23:02:17 +00003567 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3568 return;
3569}
3570
3571/// \brief Attempt character array initialization from a string literal
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003572/// (C++ [dcl.init.string], C99 6.7.8).
3573static void TryStringLiteralInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003574 const InitializedEntity &Entity,
3575 const InitializationKind &Kind,
3576 Expr *Initializer,
3577 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003578 Sequence.AddStringInitStep(Entity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003579}
3580
Douglas Gregor71d17402009-12-15 00:01:57 +00003581/// \brief Attempt value initialization (C++ [dcl.init]p7).
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003582static void TryValueInitialization(Sema &S,
Douglas Gregor71d17402009-12-15 00:01:57 +00003583 const InitializedEntity &Entity,
3584 const InitializationKind &Kind,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003585 InitializationSequence &Sequence,
3586 InitListExpr *InitList) {
3587 assert((!InitList || InitList->getNumInits() == 0) &&
3588 "Shouldn't use value-init for non-empty init lists");
3589
Richard Smith1d0c9a82012-02-14 21:14:13 +00003590 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
Douglas Gregor71d17402009-12-15 00:01:57 +00003591 //
3592 // To value-initialize an object of type T means:
Douglas Gregord6542d82009-12-22 15:35:07 +00003593 QualType T = Entity.getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003594
Douglas Gregor71d17402009-12-15 00:01:57 +00003595 // -- if T is an array type, then each element is value-initialized;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003596 T = S.Context.getBaseElementType(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003597
Douglas Gregor71d17402009-12-15 00:01:57 +00003598 if (const RecordType *RT = T->getAs<RecordType>()) {
3599 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003600 bool NeedZeroInitialization = true;
Richard Smith80ad52f2013-01-02 11:42:31 +00003601 if (!S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003602 // C++98:
3603 // -- if T is a class type (clause 9) with a user-declared constructor
3604 // (12.1), then the default constructor for T is called (and the
3605 // initialization is ill-formed if T has no accessible default
3606 // constructor);
Richard Smith1d0c9a82012-02-14 21:14:13 +00003607 if (ClassDecl->hasUserDeclaredConstructor())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003608 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003609 } else {
3610 // C++11:
3611 // -- if T is a class type (clause 9) with either no default constructor
3612 // (12.1 [class.ctor]) or a default constructor that is user-provided
3613 // or deleted, then the object is default-initialized;
3614 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
3615 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003616 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003617 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003618
Richard Smith1d0c9a82012-02-14 21:14:13 +00003619 // -- if T is a (possibly cv-qualified) non-union class type without a
3620 // user-provided or deleted default constructor, then the object is
3621 // zero-initialized and, if T has a non-trivial default constructor,
3622 // default-initialized;
Richard Smith6678a052012-10-18 00:44:17 +00003623 // The 'non-union' here was removed by DR1502. The 'non-trivial default
3624 // constructor' part was removed by DR1507.
Richard Smithf4bb8d02012-07-05 08:39:21 +00003625 if (NeedZeroInitialization)
3626 Sequence.AddZeroInitializationStep(Entity.getType());
3627
Richard Smithd5bc8672012-12-08 02:01:17 +00003628 // C++03:
3629 // -- if T is a non-union class type without a user-declared constructor,
3630 // then every non-static data member and base class component of T is
3631 // value-initialized;
3632 // [...] A program that calls for [...] value-initialization of an
3633 // entity of reference type is ill-formed.
3634 //
3635 // C++11 doesn't need this handling, because value-initialization does not
3636 // occur recursively there, and the implicit default constructor is
3637 // defined as deleted in the problematic cases.
Richard Smith80ad52f2013-01-02 11:42:31 +00003638 if (!S.getLangOpts().CPlusPlus11 &&
Richard Smithd5bc8672012-12-08 02:01:17 +00003639 ClassDecl->hasUninitializedReferenceMember()) {
3640 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
3641 return;
3642 }
3643
Richard Smithf4bb8d02012-07-05 08:39:21 +00003644 // If this is list-value-initialization, pass the empty init list on when
3645 // building the constructor call. This affects the semantics of a few
3646 // things (such as whether an explicit default constructor can be called).
3647 Expr *InitListAsExpr = InitList;
3648 Expr **Args = InitList ? &InitListAsExpr : 0;
3649 unsigned NumArgs = InitList ? 1 : 0;
3650 bool InitListSyntax = InitList;
3651
3652 return TryConstructorInitialization(S, Entity, Kind, Args, NumArgs, T,
3653 Sequence, InitListSyntax);
Douglas Gregor71d17402009-12-15 00:01:57 +00003654 }
3655 }
3656
Douglas Gregord6542d82009-12-22 15:35:07 +00003657 Sequence.AddZeroInitializationStep(Entity.getType());
Douglas Gregor71d17402009-12-15 00:01:57 +00003658}
3659
Douglas Gregor99a2e602009-12-16 01:38:02 +00003660/// \brief Attempt default initialization (C++ [dcl.init]p6).
3661static void TryDefaultInitialization(Sema &S,
3662 const InitializedEntity &Entity,
3663 const InitializationKind &Kind,
3664 InitializationSequence &Sequence) {
3665 assert(Kind.getKind() == InitializationKind::IK_Default);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003666
Douglas Gregor99a2e602009-12-16 01:38:02 +00003667 // C++ [dcl.init]p6:
3668 // To default-initialize an object of type T means:
3669 // - if T is an array type, each element is default-initialized;
John McCallf85e1932011-06-15 23:02:42 +00003670 QualType DestType = S.Context.getBaseElementType(Entity.getType());
3671
Douglas Gregor99a2e602009-12-16 01:38:02 +00003672 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
3673 // constructor for T is called (and the initialization is ill-formed if
3674 // T has no accessible default constructor);
David Blaikie4e4d0842012-03-11 07:00:24 +00003675 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
Chandler Carruth4e6fbce2010-08-23 07:55:51 +00003676 TryConstructorInitialization(S, Entity, Kind, 0, 0, DestType, Sequence);
3677 return;
Douglas Gregor99a2e602009-12-16 01:38:02 +00003678 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003679
Douglas Gregor99a2e602009-12-16 01:38:02 +00003680 // - otherwise, no initialization is performed.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003681
Douglas Gregor99a2e602009-12-16 01:38:02 +00003682 // If a program calls for the default initialization of an object of
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003683 // a const-qualified type T, T shall be a class type with a user-provided
Douglas Gregor99a2e602009-12-16 01:38:02 +00003684 // default constructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00003685 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
Douglas Gregor99a2e602009-12-16 01:38:02 +00003686 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
John McCallf85e1932011-06-15 23:02:42 +00003687 return;
3688 }
3689
3690 // If the destination type has a lifetime property, zero-initialize it.
3691 if (DestType.getQualifiers().hasObjCLifetime()) {
3692 Sequence.AddZeroInitializationStep(Entity.getType());
3693 return;
3694 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00003695}
3696
Douglas Gregor20093b42009-12-09 23:02:17 +00003697/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
3698/// which enumerates all conversion functions and performs overload resolution
3699/// to select the best.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003700static void TryUserDefinedConversion(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003701 const InitializedEntity &Entity,
3702 const InitializationKind &Kind,
3703 Expr *Initializer,
3704 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003705 QualType DestType = Entity.getType();
Douglas Gregor4a520a22009-12-14 17:27:33 +00003706 assert(!DestType->isReferenceType() && "References are handled elsewhere");
3707 QualType SourceType = Initializer->getType();
3708 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
3709 "Must have a class type to perform a user-defined conversion");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003710
Douglas Gregor4a520a22009-12-14 17:27:33 +00003711 // Build the candidate set directly in the initialization sequence
3712 // structure, so that it will persist if we fail.
3713 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3714 CandidateSet.clear();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003715
Douglas Gregor4a520a22009-12-14 17:27:33 +00003716 // Determine whether we are allowed to call explicit constructors or
3717 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003718 bool AllowExplicit = Kind.AllowExplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003719
Douglas Gregor4a520a22009-12-14 17:27:33 +00003720 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
3721 // The type we're converting to is a class type. Enumerate its constructors
3722 // to see if there is a suitable conversion.
3723 CXXRecordDecl *DestRecordDecl
3724 = cast<CXXRecordDecl>(DestRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003725
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003726 // Try to complete the type we're converting to.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003727 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
David Blaikie3bc93e32012-12-19 00:45:41 +00003728 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
David Blaikie3d5cf5e2012-10-18 16:57:32 +00003729 // The container holding the constructors can under certain conditions
3730 // be changed while iterating. To be safe we copy the lookup results
3731 // to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003732 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
David Blaikie3d5cf5e2012-10-18 16:57:32 +00003733 for (SmallVector<NamedDecl*, 8>::iterator
3734 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003735 Con != ConEnd; ++Con) {
3736 NamedDecl *D = *Con;
3737 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003738
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003739 // Find the constructor (which may be a template).
3740 CXXConstructorDecl *Constructor = 0;
3741 FunctionTemplateDecl *ConstructorTmpl
3742 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor4a520a22009-12-14 17:27:33 +00003743 if (ConstructorTmpl)
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003744 Constructor = cast<CXXConstructorDecl>(
3745 ConstructorTmpl->getTemplatedDecl());
Douglas Gregor4712c022010-07-01 03:43:00 +00003746 else
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003747 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003748
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003749 if (!Constructor->isInvalidDecl() &&
3750 Constructor->isConvertingConstructor(AllowExplicit)) {
3751 if (ConstructorTmpl)
3752 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3753 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003754 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00003755 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003756 else
3757 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003758 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00003759 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003760 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003761 }
Douglas Gregor087fb7d2010-04-26 14:36:57 +00003762 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00003763 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003764
3765 SourceLocation DeclLoc = Initializer->getLocStart();
3766
Douglas Gregor4a520a22009-12-14 17:27:33 +00003767 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
3768 // The type we're converting from is a class type, enumerate its conversion
3769 // functions.
Eli Friedmancfdc81a2009-12-19 08:11:05 +00003770
Eli Friedman33c2da92009-12-20 22:12:03 +00003771 // We can only enumerate the conversion functions for a complete type; if
3772 // the type isn't complete, simply skip this step.
3773 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
3774 CXXRecordDecl *SourceRecordDecl
3775 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003776
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00003777 std::pair<CXXRecordDecl::conversion_iterator,
3778 CXXRecordDecl::conversion_iterator>
3779 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
3780 for (CXXRecordDecl::conversion_iterator
3781 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Eli Friedman33c2da92009-12-20 22:12:03 +00003782 NamedDecl *D = *I;
3783 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3784 if (isa<UsingShadowDecl>(D))
3785 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003786
Eli Friedman33c2da92009-12-20 22:12:03 +00003787 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3788 CXXConversionDecl *Conv;
Douglas Gregor4a520a22009-12-14 17:27:33 +00003789 if (ConvTemplate)
Eli Friedman33c2da92009-12-20 22:12:03 +00003790 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
Douglas Gregor4a520a22009-12-14 17:27:33 +00003791 else
John McCall32daa422010-03-31 01:36:47 +00003792 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003793
Eli Friedman33c2da92009-12-20 22:12:03 +00003794 if (AllowExplicit || !Conv->isExplicit()) {
3795 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00003796 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00003797 ActingDC, Initializer, DestType,
Eli Friedman33c2da92009-12-20 22:12:03 +00003798 CandidateSet);
3799 else
John McCall9aa472c2010-03-19 07:35:19 +00003800 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
John McCall86820f52010-01-26 01:37:31 +00003801 Initializer, DestType, CandidateSet);
Eli Friedman33c2da92009-12-20 22:12:03 +00003802 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00003803 }
3804 }
3805 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003806
3807 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor4a520a22009-12-14 17:27:33 +00003808 OverloadCandidateSet::iterator Best;
John McCall1d318332010-01-12 00:44:57 +00003809 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00003810 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
Douglas Gregor4a520a22009-12-14 17:27:33 +00003811 Sequence.SetOverloadFailure(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003812 InitializationSequence::FK_UserConversionOverloadFailed,
Douglas Gregor4a520a22009-12-14 17:27:33 +00003813 Result);
3814 return;
3815 }
John McCall1d318332010-01-12 00:44:57 +00003816
Douglas Gregor4a520a22009-12-14 17:27:33 +00003817 FunctionDecl *Function = Best->Function;
Eli Friedman5f2987c2012-02-02 03:46:19 +00003818 S.MarkFunctionReferenced(DeclLoc, Function);
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003819 bool HadMultipleCandidates = (CandidateSet.size() > 1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003820
Douglas Gregor4a520a22009-12-14 17:27:33 +00003821 if (isa<CXXConstructorDecl>(Function)) {
3822 // Add the user-defined conversion step. Any cv-qualification conversion is
Richard Smithf2e4dfc2012-02-11 19:22:50 +00003823 // subsumed by the initialization. Per DR5, the created temporary is of the
3824 // cv-unqualified type of the destination.
3825 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
3826 DestType.getUnqualifiedType(),
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003827 HadMultipleCandidates);
Douglas Gregor4a520a22009-12-14 17:27:33 +00003828 return;
3829 }
3830
3831 // Add the user-defined conversion step that calls the conversion function.
Douglas Gregor5291c3c2010-07-13 08:18:22 +00003832 QualType ConvType = Function->getCallResultType();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00003833 if (ConvType->getAs<RecordType>()) {
Richard Smithf2e4dfc2012-02-11 19:22:50 +00003834 // If we're converting to a class type, there may be an copy of
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00003835 // the resulting temporary object (possible to create an object of
3836 // a base class type). That copy is not a separate conversion, so
3837 // we just make a note of the actual destination type (possibly a
3838 // base class of the type returned by the conversion function) and
3839 // let the user-defined conversion step handle the conversion.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003840 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
3841 HadMultipleCandidates);
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00003842 return;
3843 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00003844
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003845 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
3846 HadMultipleCandidates);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003847
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00003848 // If the conversion following the call to the conversion function
3849 // is interesting, add it as a separate step.
Douglas Gregor4a520a22009-12-14 17:27:33 +00003850 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
3851 Best->FinalConversion.Third) {
3852 ImplicitConversionSequence ICS;
John McCall1d318332010-01-12 00:44:57 +00003853 ICS.setStandard();
Douglas Gregor4a520a22009-12-14 17:27:33 +00003854 ICS.Standard = Best->FinalConversion;
3855 Sequence.AddConversionSequenceStep(ICS, DestType);
3856 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003857}
3858
John McCallf85e1932011-06-15 23:02:42 +00003859/// The non-zero enum values here are indexes into diagnostic alternatives.
3860enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
3861
3862/// Determines whether this expression is an acceptable ICR source.
John McCallc03fa492011-06-27 23:59:58 +00003863static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003864 bool isAddressOf, bool &isWeakAccess) {
John McCallf85e1932011-06-15 23:02:42 +00003865 // Skip parens.
3866 e = e->IgnoreParens();
3867
3868 // Skip address-of nodes.
3869 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
3870 if (op->getOpcode() == UO_AddrOf)
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003871 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
3872 isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00003873
3874 // Skip certain casts.
John McCallc03fa492011-06-27 23:59:58 +00003875 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
3876 switch (ce->getCastKind()) {
John McCallf85e1932011-06-15 23:02:42 +00003877 case CK_Dependent:
3878 case CK_BitCast:
3879 case CK_LValueBitCast:
John McCallf85e1932011-06-15 23:02:42 +00003880 case CK_NoOp:
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003881 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00003882
3883 case CK_ArrayToPointerDecay:
3884 return IIK_nonscalar;
3885
3886 case CK_NullToPointer:
3887 return IIK_okay;
3888
3889 default:
3890 break;
3891 }
3892
3893 // If we have a declaration reference, it had better be a local variable.
John McCallf4b88a42012-03-10 09:33:50 +00003894 } else if (isa<DeclRefExpr>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003895 // set isWeakAccess to true, to mean that there will be an implicit
3896 // load which requires a cleanup.
3897 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
3898 isWeakAccess = true;
3899
John McCallc03fa492011-06-27 23:59:58 +00003900 if (!isAddressOf) return IIK_nonlocal;
3901
John McCallf4b88a42012-03-10 09:33:50 +00003902 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
3903 if (!var) return IIK_nonlocal;
John McCallc03fa492011-06-27 23:59:58 +00003904
3905 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
John McCallf85e1932011-06-15 23:02:42 +00003906
3907 // If we have a conditional operator, check both sides.
3908 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003909 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
3910 isWeakAccess))
John McCallf85e1932011-06-15 23:02:42 +00003911 return iik;
3912
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003913 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00003914
3915 // These are never scalar.
3916 } else if (isa<ArraySubscriptExpr>(e)) {
3917 return IIK_nonscalar;
3918
3919 // Otherwise, it needs to be a null pointer constant.
3920 } else {
3921 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
3922 ? IIK_okay : IIK_nonlocal);
3923 }
3924
3925 return IIK_nonlocal;
3926}
3927
3928/// Check whether the given expression is a valid operand for an
3929/// indirect copy/restore.
3930static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
3931 assert(src->isRValue());
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00003932 bool isWeakAccess = false;
3933 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
3934 // If isWeakAccess to true, there will be an implicit
3935 // load which requires a cleanup.
3936 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
3937 S.ExprNeedsCleanups = true;
3938
John McCallf85e1932011-06-15 23:02:42 +00003939 if (iik == IIK_okay) return;
3940
3941 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
3942 << ((unsigned) iik - 1) // shift index into diagnostic explanations
3943 << src->getSourceRange();
3944}
3945
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00003946/// \brief Determine whether we have compatible array types for the
3947/// purposes of GNU by-copy array initialization.
3948static bool hasCompatibleArrayTypes(ASTContext &Context,
3949 const ArrayType *Dest,
3950 const ArrayType *Source) {
3951 // If the source and destination array types are equivalent, we're
3952 // done.
3953 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
3954 return true;
3955
3956 // Make sure that the element types are the same.
3957 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
3958 return false;
3959
3960 // The only mismatch we allow is when the destination is an
3961 // incomplete array type and the source is a constant array type.
3962 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
3963}
3964
John McCallf85e1932011-06-15 23:02:42 +00003965static bool tryObjCWritebackConversion(Sema &S,
3966 InitializationSequence &Sequence,
3967 const InitializedEntity &Entity,
3968 Expr *Initializer) {
3969 bool ArrayDecay = false;
3970 QualType ArgType = Initializer->getType();
3971 QualType ArgPointee;
3972 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
3973 ArrayDecay = true;
3974 ArgPointee = ArgArrayType->getElementType();
3975 ArgType = S.Context.getPointerType(ArgPointee);
3976 }
3977
3978 // Handle write-back conversion.
3979 QualType ConvertedArgType;
3980 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
3981 ConvertedArgType))
3982 return false;
3983
3984 // We should copy unless we're passing to an argument explicitly
3985 // marked 'out'.
3986 bool ShouldCopy = true;
3987 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
3988 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
3989
3990 // Do we need an lvalue conversion?
3991 if (ArrayDecay || Initializer->isGLValue()) {
3992 ImplicitConversionSequence ICS;
3993 ICS.setStandard();
3994 ICS.Standard.setAsIdentityConversion();
3995
3996 QualType ResultType;
3997 if (ArrayDecay) {
3998 ICS.Standard.First = ICK_Array_To_Pointer;
3999 ResultType = S.Context.getPointerType(ArgPointee);
4000 } else {
4001 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4002 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4003 }
4004
4005 Sequence.AddConversionSequenceStep(ICS, ResultType);
4006 }
4007
4008 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4009 return true;
4010}
4011
Douglas Gregor20093b42009-12-09 23:02:17 +00004012InitializationSequence::InitializationSequence(Sema &S,
4013 const InitializedEntity &Entity,
4014 const InitializationKind &Kind,
4015 Expr **Args,
John McCall5769d612010-02-08 23:07:23 +00004016 unsigned NumArgs)
4017 : FailedCandidateSet(Kind.getLocation()) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004018 ASTContext &Context = S.Context;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004019
Douglas Gregor20093b42009-12-09 23:02:17 +00004020 // C++0x [dcl.init]p16:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004021 // The semantics of initializers are as follows. The destination type is
4022 // the type of the object or reference being initialized and the source
Douglas Gregor20093b42009-12-09 23:02:17 +00004023 // type is the type of the initializer expression. The source type is not
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004024 // defined when the initializer is a braced-init-list or when it is a
Douglas Gregor20093b42009-12-09 23:02:17 +00004025 // parenthesized list of expressions.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004026 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00004027
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004028 if (DestType->isDependentType() ||
Ahmed Charles13a140c2012-02-25 11:00:22 +00004029 Expr::hasAnyTypeDependentArguments(llvm::makeArrayRef(Args, NumArgs))) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004030 SequenceKind = DependentSequence;
4031 return;
4032 }
4033
Sebastian Redl7491c492011-06-05 13:59:11 +00004034 // Almost everything is a normal sequence.
4035 setSequenceKind(NormalSequence);
4036
John McCall241d5582010-12-07 22:54:16 +00004037 for (unsigned I = 0; I != NumArgs; ++I)
John McCall32509f12011-11-15 01:35:18 +00004038 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
John McCall5acb0c92011-10-17 18:40:02 +00004039 // FIXME: should we be doing this here?
John McCall32509f12011-11-15 01:35:18 +00004040 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4041 if (result.isInvalid()) {
4042 SetFailed(FK_PlaceholderType);
4043 return;
John McCall5acb0c92011-10-17 18:40:02 +00004044 }
John McCall32509f12011-11-15 01:35:18 +00004045 Args[I] = result.take();
John Wiegley429bb272011-04-08 18:41:53 +00004046 }
John McCall241d5582010-12-07 22:54:16 +00004047
John McCall5acb0c92011-10-17 18:40:02 +00004048
Douglas Gregor20093b42009-12-09 23:02:17 +00004049 QualType SourceType;
4050 Expr *Initializer = 0;
Douglas Gregor99a2e602009-12-16 01:38:02 +00004051 if (NumArgs == 1) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004052 Initializer = Args[0];
4053 if (!isa<InitListExpr>(Initializer))
4054 SourceType = Initializer->getType();
4055 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004056
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00004057 // - If the initializer is a (non-parenthesized) braced-init-list, the
4058 // object is list-initialized (8.5.4).
4059 if (Kind.getKind() != InitializationKind::IK_Direct) {
4060 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4061 TryListInitialization(S, Entity, Kind, InitList, *this);
4062 return;
4063 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004064 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004065
Douglas Gregor20093b42009-12-09 23:02:17 +00004066 // - If the destination type is a reference type, see 8.5.3.
4067 if (DestType->isReferenceType()) {
4068 // C++0x [dcl.init.ref]p1:
4069 // A variable declared to be a T& or T&&, that is, "reference to type T"
4070 // (8.3.2), shall be initialized by an object, or function, of type T or
4071 // by an object that can be converted into a T.
4072 // (Therefore, multiple arguments are not permitted.)
4073 if (NumArgs != 1)
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004074 SetFailed(FK_TooManyInitsForReference);
Douglas Gregor20093b42009-12-09 23:02:17 +00004075 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004076 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004077 return;
4078 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004079
Douglas Gregor20093b42009-12-09 23:02:17 +00004080 // - If the initializer is (), the object is value-initialized.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004081 if (Kind.getKind() == InitializationKind::IK_Value ||
4082 (Kind.getKind() == InitializationKind::IK_Direct && NumArgs == 0)) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004083 TryValueInitialization(S, Entity, Kind, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004084 return;
4085 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004086
Douglas Gregor99a2e602009-12-16 01:38:02 +00004087 // Handle default initialization.
Nick Lewycky7663f392010-11-20 01:29:55 +00004088 if (Kind.getKind() == InitializationKind::IK_Default) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004089 TryDefaultInitialization(S, Entity, Kind, *this);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004090 return;
4091 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004092
John McCallce6c9b72011-02-21 07:22:22 +00004093 // - If the destination type is an array of characters, an array of
4094 // char16_t, an array of char32_t, or an array of wchar_t, and the
4095 // initializer is a string literal, see 8.5.2.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004096 // - Otherwise, if the destination type is an array, the program is
Douglas Gregor20093b42009-12-09 23:02:17 +00004097 // ill-formed.
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004098 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
John McCall73076432012-01-05 00:13:19 +00004099 if (Initializer && isa<VariableArrayType>(DestAT)) {
4100 SetFailed(FK_VariableLengthArrayHasInitializer);
4101 return;
4102 }
4103
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004104 if (Initializer && IsStringInit(Initializer, DestAT, Context)) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004105 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
John McCallce6c9b72011-02-21 07:22:22 +00004106 return;
4107 }
4108
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004109 // Note: as an GNU C extension, we allow initialization of an
4110 // array from a compound literal that creates an array of the same
4111 // type, so long as the initializer has no side effects.
David Blaikie4e4d0842012-03-11 07:00:24 +00004112 if (!S.getLangOpts().CPlusPlus && Initializer &&
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004113 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4114 Initializer->getType()->isArrayType()) {
4115 const ArrayType *SourceAT
4116 = Context.getAsArrayType(Initializer->getType());
4117 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004118 SetFailed(FK_ArrayTypeMismatch);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004119 else if (Initializer->HasSideEffects(S.Context))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004120 SetFailed(FK_NonConstantArrayInit);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004121 else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004122 AddArrayInitStep(DestType);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004123 }
Richard Smith0f163e92012-02-15 22:38:09 +00004124 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00004125 // Note: as a GNU C++ extension, we allow list-initialization of a
4126 // class member of array type from a parenthesized initializer list.
David Blaikie4e4d0842012-03-11 07:00:24 +00004127 else if (S.getLangOpts().CPlusPlus &&
Richard Smith0f163e92012-02-15 22:38:09 +00004128 Entity.getKind() == InitializedEntity::EK_Member &&
4129 Initializer && isa<InitListExpr>(Initializer)) {
4130 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4131 *this);
4132 AddParenthesizedArrayInitStep(DestType);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004133 } else if (DestAT->getElementType()->isAnyCharacterType())
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004134 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
Douglas Gregor20093b42009-12-09 23:02:17 +00004135 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004136 SetFailed(FK_ArrayNeedsInitList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004137
Douglas Gregor20093b42009-12-09 23:02:17 +00004138 return;
4139 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004140
John McCallf85e1932011-06-15 23:02:42 +00004141 // Determine whether we should consider writeback conversions for
4142 // Objective-C ARC.
David Blaikie4e4d0842012-03-11 07:00:24 +00004143 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
John McCallf85e1932011-06-15 23:02:42 +00004144 Entity.getKind() == InitializedEntity::EK_Parameter;
4145
4146 // We're at the end of the line for C: it's either a write-back conversion
4147 // or it's a C assignment. There's no need to check anything else.
David Blaikie4e4d0842012-03-11 07:00:24 +00004148 if (!S.getLangOpts().CPlusPlus) {
John McCallf85e1932011-06-15 23:02:42 +00004149 // If allowed, check whether this is an Objective-C writeback conversion.
4150 if (allowObjCWritebackConversion &&
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004151 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
John McCallf85e1932011-06-15 23:02:42 +00004152 return;
4153 }
4154
4155 // Handle initialization in C
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004156 AddCAssignmentStep(DestType);
4157 MaybeProduceObjCObject(S, *this, Entity);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004158 return;
4159 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004160
David Blaikie4e4d0842012-03-11 07:00:24 +00004161 assert(S.getLangOpts().CPlusPlus);
John McCallf85e1932011-06-15 23:02:42 +00004162
Douglas Gregor20093b42009-12-09 23:02:17 +00004163 // - If the destination type is a (possibly cv-qualified) class type:
4164 if (DestType->isRecordType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004165 // - If the initialization is direct-initialization, or if it is
4166 // copy-initialization where the cv-unqualified version of the
4167 // source type is the same class as, or a derived class of, the
Douglas Gregor20093b42009-12-09 23:02:17 +00004168 // class of the destination, constructors are considered. [...]
4169 if (Kind.getKind() == InitializationKind::IK_Direct ||
4170 (Kind.getKind() == InitializationKind::IK_Copy &&
4171 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4172 S.IsDerivedFrom(SourceType, DestType))))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004173 TryConstructorInitialization(S, Entity, Kind, Args, NumArgs,
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004174 Entity.getType(), *this);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004175 // - Otherwise (i.e., for the remaining copy-initialization cases),
Douglas Gregor20093b42009-12-09 23:02:17 +00004176 // user-defined conversion sequences that can convert from the source
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004177 // type to the destination type or (when a conversion function is
Douglas Gregor20093b42009-12-09 23:02:17 +00004178 // used) to a derived class thereof are enumerated as described in
4179 // 13.3.1.4, and the best one is chosen through overload resolution
4180 // (13.3).
4181 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004182 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004183 return;
4184 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004185
Douglas Gregor99a2e602009-12-16 01:38:02 +00004186 if (NumArgs > 1) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004187 SetFailed(FK_TooManyInitsForScalar);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004188 return;
4189 }
4190 assert(NumArgs == 1 && "Zero-argument case handled above");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004191
4192 // - Otherwise, if the source type is a (possibly cv-qualified) class
Douglas Gregor20093b42009-12-09 23:02:17 +00004193 // type, conversion functions are considered.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004194 if (!SourceType.isNull() && SourceType->isRecordType()) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004195 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this);
4196 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00004197 return;
4198 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004199
Douglas Gregor20093b42009-12-09 23:02:17 +00004200 // - Otherwise, the initial value of the object being initialized is the
Douglas Gregor4a520a22009-12-14 17:27:33 +00004201 // (possibly converted) value of the initializer expression. Standard
Douglas Gregor20093b42009-12-09 23:02:17 +00004202 // conversions (Clause 4) will be used, if necessary, to convert the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004203 // initializer expression to the cv-unqualified version of the
Douglas Gregor20093b42009-12-09 23:02:17 +00004204 // destination type; no user-defined conversions are considered.
John McCallf85e1932011-06-15 23:02:42 +00004205
4206 ImplicitConversionSequence ICS
4207 = S.TryImplicitConversion(Initializer, Entity.getType(),
4208 /*SuppressUserConversions*/true,
John McCall369371c2010-06-04 02:29:22 +00004209 /*AllowExplicitConversions*/ false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00004210 /*InOverloadResolution*/ false,
John McCallf85e1932011-06-15 23:02:42 +00004211 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4212 allowObjCWritebackConversion);
4213
4214 if (ICS.isStandard() &&
4215 ICS.Standard.Second == ICK_Writeback_Conversion) {
4216 // Objective-C ARC writeback conversion.
4217
4218 // We should copy unless we're passing to an argument explicitly
4219 // marked 'out'.
4220 bool ShouldCopy = true;
4221 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4222 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4223
4224 // If there was an lvalue adjustment, add it as a separate conversion.
4225 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4226 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4227 ImplicitConversionSequence LvalueICS;
4228 LvalueICS.setStandard();
4229 LvalueICS.Standard.setAsIdentityConversion();
4230 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4231 LvalueICS.Standard.First = ICS.Standard.First;
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004232 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
John McCallf85e1932011-06-15 23:02:42 +00004233 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004234
4235 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
John McCallf85e1932011-06-15 23:02:42 +00004236 } else if (ICS.isBad()) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004237 DeclAccessPair dap;
4238 if (Initializer->getType() == Context.OverloadTy &&
4239 !S.ResolveAddressOfOverloadedFunction(Initializer
4240 , DestType, false, dap))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004241 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor8e960432010-11-08 03:40:48 +00004242 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004243 SetFailed(InitializationSequence::FK_ConversionFailed);
John McCallf85e1932011-06-15 23:02:42 +00004244 } else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004245 AddConversionSequenceStep(ICS, Entity.getType());
John McCall856d3792011-06-16 23:24:51 +00004246
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004247 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor8e960432010-11-08 03:40:48 +00004248 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004249}
4250
4251InitializationSequence::~InitializationSequence() {
Chris Lattner5f9e2722011-07-23 10:55:15 +00004252 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
Douglas Gregor20093b42009-12-09 23:02:17 +00004253 StepEnd = Steps.end();
4254 Step != StepEnd; ++Step)
4255 Step->Destroy();
4256}
4257
4258//===----------------------------------------------------------------------===//
4259// Perform initialization
4260//===----------------------------------------------------------------------===//
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004261static Sema::AssignmentAction
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004262getAssignmentAction(const InitializedEntity &Entity) {
4263 switch(Entity.getKind()) {
4264 case InitializedEntity::EK_Variable:
4265 case InitializedEntity::EK_New:
Douglas Gregora3998bd2010-12-02 21:47:04 +00004266 case InitializedEntity::EK_Exception:
4267 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004268 case InitializedEntity::EK_Delegating:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004269 return Sema::AA_Initializing;
4270
4271 case InitializedEntity::EK_Parameter:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004272 if (Entity.getDecl() &&
Douglas Gregor688fc9b2010-04-21 23:24:10 +00004273 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4274 return Sema::AA_Sending;
4275
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004276 return Sema::AA_Passing;
4277
4278 case InitializedEntity::EK_Result:
4279 return Sema::AA_Returning;
4280
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004281 case InitializedEntity::EK_Temporary:
4282 // FIXME: Can we tell apart casting vs. converting?
4283 return Sema::AA_Casting;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004284
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004285 case InitializedEntity::EK_Member:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004286 case InitializedEntity::EK_ArrayElement:
4287 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004288 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004289 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004290 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004291 return Sema::AA_Initializing;
4292 }
4293
David Blaikie7530c032012-01-17 06:56:22 +00004294 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004295}
4296
Richard Smith774d8b42013-01-08 00:08:23 +00004297/// \brief Whether we should bind a created object as a temporary when
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004298/// initializing the given entity.
Douglas Gregor2f599792010-04-02 18:24:57 +00004299static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004300 switch (Entity.getKind()) {
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004301 case InitializedEntity::EK_ArrayElement:
4302 case InitializedEntity::EK_Member:
Douglas Gregor2f599792010-04-02 18:24:57 +00004303 case InitializedEntity::EK_Result:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004304 case InitializedEntity::EK_New:
4305 case InitializedEntity::EK_Variable:
4306 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004307 case InitializedEntity::EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004308 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004309 case InitializedEntity::EK_ComplexElement:
Anders Carlssona508b7d2010-02-06 23:23:06 +00004310 case InitializedEntity::EK_Exception:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004311 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004312 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004313 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004314
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004315 case InitializedEntity::EK_Parameter:
4316 case InitializedEntity::EK_Temporary:
4317 return true;
4318 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004319
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004320 llvm_unreachable("missed an InitializedEntity kind?");
4321}
4322
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004323/// \brief Whether the given entity, when initialized with an object
4324/// created for that initialization, requires destruction.
4325static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4326 switch (Entity.getKind()) {
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004327 case InitializedEntity::EK_Result:
4328 case InitializedEntity::EK_New:
4329 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004330 case InitializedEntity::EK_Delegating:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004331 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004332 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004333 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004334 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004335 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004336
Richard Smith774d8b42013-01-08 00:08:23 +00004337 case InitializedEntity::EK_Member:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004338 case InitializedEntity::EK_Variable:
4339 case InitializedEntity::EK_Parameter:
4340 case InitializedEntity::EK_Temporary:
4341 case InitializedEntity::EK_ArrayElement:
4342 case InitializedEntity::EK_Exception:
4343 return true;
4344 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004345
4346 llvm_unreachable("missed an InitializedEntity kind?");
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004347}
4348
Richard Smith83da2e72011-10-19 16:55:56 +00004349/// \brief Look for copy and move constructors and constructor templates, for
4350/// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4351static void LookupCopyAndMoveConstructors(Sema &S,
4352 OverloadCandidateSet &CandidateSet,
4353 CXXRecordDecl *Class,
4354 Expr *CurInitExpr) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004355 DeclContext::lookup_result R = S.LookupConstructors(Class);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004356 // The container holding the constructors can under certain conditions
4357 // be changed while iterating (e.g. because of deserialization).
4358 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004359 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004360 for (SmallVector<NamedDecl*, 16>::iterator
4361 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4362 NamedDecl *D = *CI;
Richard Smith83da2e72011-10-19 16:55:56 +00004363 CXXConstructorDecl *Constructor = 0;
4364
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004365 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
Richard Smith83da2e72011-10-19 16:55:56 +00004366 // Handle copy/moveconstructors, only.
4367 if (!Constructor || Constructor->isInvalidDecl() ||
4368 !Constructor->isCopyOrMoveConstructor() ||
4369 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4370 continue;
4371
4372 DeclAccessPair FoundDecl
4373 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4374 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004375 CurInitExpr, CandidateSet);
Richard Smith83da2e72011-10-19 16:55:56 +00004376 continue;
4377 }
4378
4379 // Handle constructor templates.
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004380 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
Richard Smith83da2e72011-10-19 16:55:56 +00004381 if (ConstructorTmpl->isInvalidDecl())
4382 continue;
4383
4384 Constructor = cast<CXXConstructorDecl>(
4385 ConstructorTmpl->getTemplatedDecl());
4386 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4387 continue;
4388
4389 // FIXME: Do we need to limit this to copy-constructor-like
4390 // candidates?
4391 DeclAccessPair FoundDecl
4392 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
4393 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004394 CurInitExpr, CandidateSet, true);
Richard Smith83da2e72011-10-19 16:55:56 +00004395 }
4396}
4397
4398/// \brief Get the location at which initialization diagnostics should appear.
4399static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4400 Expr *Initializer) {
4401 switch (Entity.getKind()) {
4402 case InitializedEntity::EK_Result:
4403 return Entity.getReturnLoc();
4404
4405 case InitializedEntity::EK_Exception:
4406 return Entity.getThrowLoc();
4407
4408 case InitializedEntity::EK_Variable:
4409 return Entity.getDecl()->getLocation();
4410
Douglas Gregor47736542012-02-15 16:57:26 +00004411 case InitializedEntity::EK_LambdaCapture:
4412 return Entity.getCaptureLoc();
4413
Richard Smith83da2e72011-10-19 16:55:56 +00004414 case InitializedEntity::EK_ArrayElement:
4415 case InitializedEntity::EK_Member:
4416 case InitializedEntity::EK_Parameter:
4417 case InitializedEntity::EK_Temporary:
4418 case InitializedEntity::EK_New:
4419 case InitializedEntity::EK_Base:
4420 case InitializedEntity::EK_Delegating:
4421 case InitializedEntity::EK_VectorElement:
4422 case InitializedEntity::EK_ComplexElement:
4423 case InitializedEntity::EK_BlockElement:
4424 return Initializer->getLocStart();
4425 }
4426 llvm_unreachable("missed an InitializedEntity kind?");
4427}
4428
Douglas Gregor523d46a2010-04-18 07:40:54 +00004429/// \brief Make a (potentially elidable) temporary copy of the object
4430/// provided by the given initializer by calling the appropriate copy
4431/// constructor.
4432///
4433/// \param S The Sema object used for type-checking.
4434///
Abramo Bagnara63e7d252011-01-27 19:55:10 +00004435/// \param T The type of the temporary object, which must either be
Douglas Gregor523d46a2010-04-18 07:40:54 +00004436/// the type of the initializer expression or a superclass thereof.
4437///
James Dennett1dfbd922012-06-14 21:40:34 +00004438/// \param Entity The entity being initialized.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004439///
4440/// \param CurInit The initializer expression.
4441///
4442/// \param IsExtraneousCopy Whether this is an "extraneous" copy that
4443/// is permitted in C++03 (but not C++0x) when binding a reference to
4444/// an rvalue.
4445///
4446/// \returns An expression that copies the initializer expression into
4447/// a temporary object, or an error expression if a copy could not be
4448/// created.
John McCall60d7b3a2010-08-24 06:29:42 +00004449static ExprResult CopyObject(Sema &S,
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004450 QualType T,
4451 const InitializedEntity &Entity,
4452 ExprResult CurInit,
4453 bool IsExtraneousCopy) {
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004454 // Determine which class type we're copying to.
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004455 Expr *CurInitExpr = (Expr *)CurInit.get();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004456 CXXRecordDecl *Class = 0;
Douglas Gregor523d46a2010-04-18 07:40:54 +00004457 if (const RecordType *Record = T->getAs<RecordType>())
Douglas Gregor2f599792010-04-02 18:24:57 +00004458 Class = cast<CXXRecordDecl>(Record->getDecl());
4459 if (!Class)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004460 return CurInit;
Douglas Gregor2f599792010-04-02 18:24:57 +00004461
Douglas Gregorf5d8f462011-01-21 18:05:27 +00004462 // C++0x [class.copy]p32:
Douglas Gregor2f599792010-04-02 18:24:57 +00004463 // When certain criteria are met, an implementation is allowed to
4464 // omit the copy/move construction of a class object, even if the
4465 // copy/move constructor and/or destructor for the object have
4466 // side effects. [...]
4467 // - when a temporary class object that has not been bound to a
4468 // reference (12.2) would be copied/moved to a class object
4469 // with the same cv-unqualified type, the copy/move operation
4470 // can be omitted by constructing the temporary object
4471 // directly into the target of the omitted copy/move
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004472 //
Douglas Gregor2f599792010-04-02 18:24:57 +00004473 // Note that the other three bullets are handled elsewhere. Copy
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004474 // elision for return statements and throw expressions are handled as part
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004475 // of constructor initialization, while copy elision for exception handlers
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004476 // is handled by the run-time.
John McCall558d2ab2010-09-15 10:14:12 +00004477 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
Richard Smith83da2e72011-10-19 16:55:56 +00004478 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004479
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004480 // Make sure that the type we are copying is complete.
Douglas Gregord10099e2012-05-04 16:32:21 +00004481 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004482 return CurInit;
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004483
Douglas Gregorcc15f012011-01-21 19:38:21 +00004484 // Perform overload resolution using the class's copy/move constructors.
Richard Smith83da2e72011-10-19 16:55:56 +00004485 // Only consider constructors and constructor templates. Per
4486 // C++0x [dcl.init]p16, second bullet to class types, this initialization
4487 // is direct-initialization.
John McCall5769d612010-02-08 23:07:23 +00004488 OverloadCandidateSet CandidateSet(Loc);
Richard Smith83da2e72011-10-19 16:55:56 +00004489 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004490
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004491 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4492
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004493 OverloadCandidateSet::iterator Best;
Chandler Carruth25ca4212011-02-25 19:41:05 +00004494 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004495 case OR_Success:
4496 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004497
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004498 case OR_No_Viable_Function:
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004499 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
4500 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
4501 : diag::err_temp_copy_no_viable)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004502 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004503 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004504 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004505 if (!IsExtraneousCopy || S.isSFINAEContext())
John McCallf312b1e2010-08-26 23:41:50 +00004506 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004507 return CurInit;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004508
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004509 case OR_Ambiguous:
4510 S.Diag(Loc, diag::err_temp_copy_ambiguous)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004511 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004512 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004513 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
John McCallf312b1e2010-08-26 23:41:50 +00004514 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004515
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004516 case OR_Deleted:
4517 S.Diag(Loc, diag::err_temp_copy_deleted)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004518 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004519 << CurInitExpr->getSourceRange();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004520 S.NoteDeletedFunction(Best->Function);
John McCallf312b1e2010-08-26 23:41:50 +00004521 return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004522 }
4523
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004524 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00004525 SmallVector<Expr*, 8> ConstructorArgs;
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004526 CurInit.release(); // Ownership transferred into MultiExprArg, below.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004527
Anders Carlsson9a68a672010-04-21 18:47:17 +00004528 S.CheckConstructorAccess(Loc, Constructor, Entity,
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004529 Best->FoundDecl.getAccess(), IsExtraneousCopy);
Douglas Gregor523d46a2010-04-18 07:40:54 +00004530
4531 if (IsExtraneousCopy) {
4532 // If this is a totally extraneous copy for C++03 reference
4533 // binding purposes, just return the original initialization
Douglas Gregor2559a702010-04-18 07:57:34 +00004534 // expression. We don't generate an (elided) copy operation here
4535 // because doing so would require us to pass down a flag to avoid
4536 // infinite recursion, where each step adds another extraneous,
4537 // elidable copy.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004538
Douglas Gregor2559a702010-04-18 07:57:34 +00004539 // Instantiate the default arguments of any extra parameters in
4540 // the selected copy constructor, as if we were going to create a
4541 // proper call to the copy constructor.
4542 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
4543 ParmVarDecl *Parm = Constructor->getParamDecl(I);
4544 if (S.RequireCompleteType(Loc, Parm->getType(),
Douglas Gregord10099e2012-05-04 16:32:21 +00004545 diag::err_call_incomplete_argument))
Douglas Gregor2559a702010-04-18 07:57:34 +00004546 break;
4547
4548 // Build the default argument expression; we don't actually care
4549 // if this succeeds or not, because this routine will complain
4550 // if there was a problem.
4551 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
4552 }
4553
Douglas Gregor523d46a2010-04-18 07:40:54 +00004554 return S.Owned(CurInitExpr);
4555 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004556
Eli Friedman5f2987c2012-02-02 03:46:19 +00004557 S.MarkFunctionReferenced(Loc, Constructor);
Chandler Carruth25ca4212011-02-25 19:41:05 +00004558
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004559 // Determine the arguments required to actually perform the
Douglas Gregor523d46a2010-04-18 07:40:54 +00004560 // constructor call (we might have derived-to-base conversions, or
4561 // the copy constructor may have default arguments).
John McCallf312b1e2010-08-26 23:41:50 +00004562 if (S.CompleteConstructorCall(Constructor, MultiExprArg(&CurInitExpr, 1),
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004563 Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00004564 return ExprError();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004565
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00004566 // Actually perform the constructor call.
4567 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004568 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004569 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00004570 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00004571 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00004572 CXXConstructExpr::CK_Complete,
4573 SourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004574
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00004575 // If we're supposed to bind temporaries, do so.
4576 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
4577 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004578 return CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004579}
Douglas Gregor20093b42009-12-09 23:02:17 +00004580
Richard Smith83da2e72011-10-19 16:55:56 +00004581/// \brief Check whether elidable copy construction for binding a reference to
4582/// a temporary would have succeeded if we were building in C++98 mode, for
4583/// -Wc++98-compat.
4584static void CheckCXX98CompatAccessibleCopy(Sema &S,
4585 const InitializedEntity &Entity,
4586 Expr *CurInitExpr) {
Richard Smith80ad52f2013-01-02 11:42:31 +00004587 assert(S.getLangOpts().CPlusPlus11);
Richard Smith83da2e72011-10-19 16:55:56 +00004588
4589 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
4590 if (!Record)
4591 return;
4592
4593 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
4594 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc)
4595 == DiagnosticsEngine::Ignored)
4596 return;
4597
4598 // Find constructors which would have been considered.
4599 OverloadCandidateSet CandidateSet(Loc);
4600 LookupCopyAndMoveConstructors(
4601 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
4602
4603 // Perform overload resolution.
4604 OverloadCandidateSet::iterator Best;
4605 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
4606
4607 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
4608 << OR << (int)Entity.getKind() << CurInitExpr->getType()
4609 << CurInitExpr->getSourceRange();
4610
4611 switch (OR) {
4612 case OR_Success:
4613 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
John McCallb9abd8722012-04-07 03:04:20 +00004614 Entity, Best->FoundDecl.getAccess(), Diag);
Richard Smith83da2e72011-10-19 16:55:56 +00004615 // FIXME: Check default arguments as far as that's possible.
4616 break;
4617
4618 case OR_No_Viable_Function:
4619 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00004620 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00004621 break;
4622
4623 case OR_Ambiguous:
4624 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00004625 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00004626 break;
4627
4628 case OR_Deleted:
4629 S.Diag(Loc, Diag);
Richard Smith6c4c36c2012-03-30 20:53:28 +00004630 S.NoteDeletedFunction(Best->Function);
Richard Smith83da2e72011-10-19 16:55:56 +00004631 break;
4632 }
4633}
4634
Douglas Gregora41a8c52010-04-22 00:20:18 +00004635void InitializationSequence::PrintInitLocationNote(Sema &S,
4636 const InitializedEntity &Entity) {
4637 if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) {
4638 if (Entity.getDecl()->getLocation().isInvalid())
4639 return;
4640
4641 if (Entity.getDecl()->getDeclName())
4642 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
4643 << Entity.getDecl()->getDeclName();
4644 else
4645 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
4646 }
4647}
4648
Sebastian Redl3b802322011-07-14 19:07:55 +00004649static bool isReferenceBinding(const InitializationSequence::Step &s) {
4650 return s.Kind == InitializationSequence::SK_BindReference ||
4651 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
4652}
4653
Sebastian Redl10f04a62011-12-22 14:44:04 +00004654static ExprResult
4655PerformConstructorInitialization(Sema &S,
4656 const InitializedEntity &Entity,
4657 const InitializationKind &Kind,
4658 MultiExprArg Args,
4659 const InitializationSequence::Step& Step,
Richard Smithc83c2302012-12-19 01:39:02 +00004660 bool &ConstructorInitRequiresZeroInit,
4661 bool IsListInitialization) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00004662 unsigned NumArgs = Args.size();
4663 CXXConstructorDecl *Constructor
4664 = cast<CXXConstructorDecl>(Step.Function.Function);
4665 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
4666
4667 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00004668 SmallVector<Expr*, 8> ConstructorArgs;
Sebastian Redl10f04a62011-12-22 14:44:04 +00004669 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
4670 ? Kind.getEqualLoc()
4671 : Kind.getLocation();
4672
4673 if (Kind.getKind() == InitializationKind::IK_Default) {
4674 // Force even a trivial, implicit default constructor to be
4675 // semantically checked. We do this explicitly because we don't build
4676 // the definition for completely trivial constructors.
Matt Beaumont-Gay28e47022012-02-24 08:37:56 +00004677 assert(Constructor->getParent() && "No parent class for constructor.");
Sebastian Redl10f04a62011-12-22 14:44:04 +00004678 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Douglas Gregor5d86f612012-02-24 07:48:37 +00004679 Constructor->isTrivial() && !Constructor->isUsed(false))
Sebastian Redl10f04a62011-12-22 14:44:04 +00004680 S.DefineImplicitDefaultConstructor(Loc, Constructor);
4681 }
4682
4683 ExprResult CurInit = S.Owned((Expr *)0);
4684
Douglas Gregored878af2012-02-24 23:56:31 +00004685 // C++ [over.match.copy]p1:
4686 // - When initializing a temporary to be bound to the first parameter
4687 // of a constructor that takes a reference to possibly cv-qualified
4688 // T as its first argument, called with a single argument in the
4689 // context of direct-initialization, explicit conversion functions
4690 // are also considered.
4691 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
4692 Args.size() == 1 &&
4693 Constructor->isCopyOrMoveConstructor();
4694
Sebastian Redl10f04a62011-12-22 14:44:04 +00004695 // Determine the arguments required to actually perform the constructor
4696 // call.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004697 if (S.CompleteConstructorCall(Constructor, Args,
Douglas Gregored878af2012-02-24 23:56:31 +00004698 Loc, ConstructorArgs,
4699 AllowExplicitConv))
Sebastian Redl10f04a62011-12-22 14:44:04 +00004700 return ExprError();
4701
4702
4703 if (Entity.getKind() == InitializedEntity::EK_Temporary &&
Sebastian Redl188158d2012-03-08 21:05:45 +00004704 (Kind.getKind() == InitializationKind::IK_DirectList ||
4705 (NumArgs != 1 && // FIXME: Hack to work around cast weirdness
4706 (Kind.getKind() == InitializationKind::IK_Direct ||
4707 Kind.getKind() == InitializationKind::IK_Value)))) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00004708 // An explicitly-constructed temporary, e.g., X(1, 2).
Eli Friedman5f2987c2012-02-02 03:46:19 +00004709 S.MarkFunctionReferenced(Loc, Constructor);
Sebastian Redl10f04a62011-12-22 14:44:04 +00004710 S.DiagnoseUseOfDecl(Constructor, Loc);
4711
4712 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
4713 if (!TSInfo)
4714 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
Sebastian Redl188158d2012-03-08 21:05:45 +00004715 SourceRange ParenRange;
4716 if (Kind.getKind() != InitializationKind::IK_DirectList)
4717 ParenRange = Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00004718
Richard Smithc83c2302012-12-19 01:39:02 +00004719 CurInit = S.Owned(
4720 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor,
4721 TSInfo, ConstructorArgs,
4722 ParenRange, IsListInitialization,
4723 HadMultipleCandidates,
4724 ConstructorInitRequiresZeroInit));
Sebastian Redl10f04a62011-12-22 14:44:04 +00004725 } else {
4726 CXXConstructExpr::ConstructionKind ConstructKind =
4727 CXXConstructExpr::CK_Complete;
4728
4729 if (Entity.getKind() == InitializedEntity::EK_Base) {
4730 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
4731 CXXConstructExpr::CK_VirtualBase :
4732 CXXConstructExpr::CK_NonVirtualBase;
4733 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
4734 ConstructKind = CXXConstructExpr::CK_Delegating;
4735 }
4736
4737 // Only get the parenthesis range if it is a direct construction.
4738 SourceRange parenRange =
4739 Kind.getKind() == InitializationKind::IK_Direct ?
4740 Kind.getParenRange() : SourceRange();
4741
4742 // If the entity allows NRVO, mark the construction as elidable
4743 // unconditionally.
4744 if (Entity.allowsNRVO())
4745 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
4746 Constructor, /*Elidable=*/true,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004747 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00004748 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00004749 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00004750 ConstructorInitRequiresZeroInit,
4751 ConstructKind,
4752 parenRange);
4753 else
4754 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
4755 Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004756 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00004757 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00004758 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00004759 ConstructorInitRequiresZeroInit,
4760 ConstructKind,
4761 parenRange);
4762 }
4763 if (CurInit.isInvalid())
4764 return ExprError();
4765
4766 // Only check access if all of that succeeded.
4767 S.CheckConstructorAccess(Loc, Constructor, Entity,
4768 Step.Function.FoundDecl.getAccess());
4769 S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc);
4770
4771 if (shouldBindAsTemporary(Entity))
4772 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
4773
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004774 return CurInit;
Sebastian Redl10f04a62011-12-22 14:44:04 +00004775}
4776
Richard Smith36d02af2012-06-04 22:27:30 +00004777/// Determine whether the specified InitializedEntity definitely has a lifetime
4778/// longer than the current full-expression. Conservatively returns false if
4779/// it's unclear.
4780static bool
4781InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
4782 const InitializedEntity *Top = &Entity;
4783 while (Top->getParent())
4784 Top = Top->getParent();
4785
4786 switch (Top->getKind()) {
4787 case InitializedEntity::EK_Variable:
4788 case InitializedEntity::EK_Result:
4789 case InitializedEntity::EK_Exception:
4790 case InitializedEntity::EK_Member:
4791 case InitializedEntity::EK_New:
4792 case InitializedEntity::EK_Base:
4793 case InitializedEntity::EK_Delegating:
4794 return true;
4795
4796 case InitializedEntity::EK_ArrayElement:
4797 case InitializedEntity::EK_VectorElement:
4798 case InitializedEntity::EK_BlockElement:
4799 case InitializedEntity::EK_ComplexElement:
4800 // Could not determine what the full initialization is. Assume it might not
4801 // outlive the full-expression.
4802 return false;
4803
4804 case InitializedEntity::EK_Parameter:
4805 case InitializedEntity::EK_Temporary:
4806 case InitializedEntity::EK_LambdaCapture:
4807 // The entity being initialized might not outlive the full-expression.
4808 return false;
4809 }
4810
4811 llvm_unreachable("unknown entity kind");
4812}
4813
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004814ExprResult
Douglas Gregor20093b42009-12-09 23:02:17 +00004815InitializationSequence::Perform(Sema &S,
4816 const InitializedEntity &Entity,
4817 const InitializationKind &Kind,
John McCallf312b1e2010-08-26 23:41:50 +00004818 MultiExprArg Args,
Douglas Gregord87b61f2009-12-10 17:56:55 +00004819 QualType *ResultType) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00004820 if (Failed()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004821 unsigned NumArgs = Args.size();
Benjamin Kramer5354e772012-08-23 23:38:35 +00004822 Diagnose(S, Entity, Kind, Args.data(), NumArgs);
John McCallf312b1e2010-08-26 23:41:50 +00004823 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00004824 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004825
Sebastian Redl7491c492011-06-05 13:59:11 +00004826 if (getKind() == DependentSequence) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00004827 // If the declaration is a non-dependent, incomplete array type
4828 // that has an initializer, then its type will be completed once
4829 // the initializer is instantiated.
Douglas Gregord6542d82009-12-22 15:35:07 +00004830 if (ResultType && !Entity.getType()->isDependentType() &&
Douglas Gregord87b61f2009-12-10 17:56:55 +00004831 Args.size() == 1) {
Douglas Gregord6542d82009-12-22 15:35:07 +00004832 QualType DeclType = Entity.getType();
Douglas Gregord87b61f2009-12-10 17:56:55 +00004833 if (const IncompleteArrayType *ArrayT
4834 = S.Context.getAsIncompleteArrayType(DeclType)) {
4835 // FIXME: We don't currently have the ability to accurately
4836 // compute the length of an initializer list without
4837 // performing full type-checking of the initializer list
4838 // (since we have to determine where braces are implicitly
4839 // introduced and such). So, we fall back to making the array
4840 // type a dependently-sized array type with no specified
4841 // bound.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004842 if (isa<InitListExpr>((Expr *)Args[0])) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00004843 SourceRange Brackets;
Douglas Gregord6542d82009-12-22 15:35:07 +00004844
Douglas Gregord87b61f2009-12-10 17:56:55 +00004845 // Scavange the location of the brackets from the entity, if we can.
Douglas Gregord6542d82009-12-22 15:35:07 +00004846 if (DeclaratorDecl *DD = Entity.getDecl()) {
4847 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
4848 TypeLoc TL = TInfo->getTypeLoc();
4849 if (IncompleteArrayTypeLoc *ArrayLoc
4850 = dyn_cast<IncompleteArrayTypeLoc>(&TL))
4851 Brackets = ArrayLoc->getBracketsRange();
4852 }
Douglas Gregord87b61f2009-12-10 17:56:55 +00004853 }
4854
4855 *ResultType
4856 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
4857 /*NumElts=*/0,
4858 ArrayT->getSizeModifier(),
4859 ArrayT->getIndexTypeCVRQualifiers(),
4860 Brackets);
4861 }
4862
4863 }
4864 }
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00004865 if (Kind.getKind() == InitializationKind::IK_Direct &&
4866 !Kind.isExplicitCast()) {
4867 // Rebuild the ParenListExpr.
4868 SourceRange ParenRange = Kind.getParenRange();
4869 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004870 Args);
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00004871 }
Manuel Klimek0d9106f2011-06-22 20:02:16 +00004872 assert(Kind.getKind() == InitializationKind::IK_Copy ||
Douglas Gregora9b55a42012-04-04 04:06:51 +00004873 Kind.isExplicitCast() ||
4874 Kind.getKind() == InitializationKind::IK_DirectList);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004875 return ExprResult(Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00004876 }
4877
Sebastian Redl7491c492011-06-05 13:59:11 +00004878 // No steps means no initialization.
4879 if (Steps.empty())
Douglas Gregor99a2e602009-12-16 01:38:02 +00004880 return S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004881
Richard Smith80ad52f2013-01-02 11:42:31 +00004882 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004883 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
Richard Smith193649c2013-01-12 01:05:20 +00004884 cast<InitListExpr>(Args[0])->getNumInits() == 1 &&
Richard Smith03544fc2012-04-19 06:58:00 +00004885 Entity.getKind() != InitializedEntity::EK_Parameter) {
4886 // Produce a C++98 compatibility warning if we are initializing a reference
4887 // from an initializer list. For parameters, we produce a better warning
4888 // elsewhere.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004889 Expr *Init = Args[0];
Richard Smith03544fc2012-04-19 06:58:00 +00004890 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
4891 << Init->getSourceRange();
4892 }
4893
Richard Smith36d02af2012-06-04 22:27:30 +00004894 // Diagnose cases where we initialize a pointer to an array temporary, and the
4895 // pointer obviously outlives the temporary.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004896 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Richard Smith36d02af2012-06-04 22:27:30 +00004897 Entity.getType()->isPointerType() &&
4898 InitializedEntityOutlivesFullExpression(Entity)) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004899 Expr *Init = Args[0];
Richard Smith36d02af2012-06-04 22:27:30 +00004900 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
4901 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
4902 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
4903 << Init->getSourceRange();
4904 }
4905
Douglas Gregord6542d82009-12-22 15:35:07 +00004906 QualType DestType = Entity.getType().getNonReferenceType();
4907 // FIXME: Ugly hack around the fact that Entity.getType() is not
Eli Friedmana91eb542009-12-22 02:10:53 +00004908 // the same as Entity.getDecl()->getType() in cases involving type merging,
4909 // and we want latter when it makes sense.
Douglas Gregord87b61f2009-12-10 17:56:55 +00004910 if (ResultType)
Eli Friedmana91eb542009-12-22 02:10:53 +00004911 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
Douglas Gregord6542d82009-12-22 15:35:07 +00004912 Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00004913
John McCall60d7b3a2010-08-24 06:29:42 +00004914 ExprResult CurInit = S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004915
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004916 // For initialization steps that start with a single initializer,
Douglas Gregor99a2e602009-12-16 01:38:02 +00004917 // grab the only argument out the Args and place it into the "current"
4918 // initializer.
4919 switch (Steps.front().Kind) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004920 case SK_ResolveAddressOfOverloadedFunction:
4921 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00004922 case SK_CastDerivedToBaseXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004923 case SK_CastDerivedToBaseLValue:
4924 case SK_BindReference:
4925 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00004926 case SK_ExtraneousCopyToTemporary:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004927 case SK_UserConversion:
4928 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00004929 case SK_QualificationConversionXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004930 case SK_QualificationConversionRValue:
4931 case SK_ConversionSequence:
4932 case SK_ListInitialization:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00004933 case SK_UnwrapInitList:
4934 case SK_RewrapInitList:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004935 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004936 case SK_StringInit:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004937 case SK_ObjCObjectConversion:
John McCallf85e1932011-06-15 23:02:42 +00004938 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00004939 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00004940 case SK_PassByIndirectCopyRestore:
4941 case SK_PassByIndirectRestore:
Sebastian Redl2b916b82012-01-17 22:49:42 +00004942 case SK_ProduceObjCObject:
4943 case SK_StdInitializerList: {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004944 assert(Args.size() == 1);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004945 CurInit = Args[0];
John Wiegley429bb272011-04-08 18:41:53 +00004946 if (!CurInit.get()) return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004947 break;
John McCallf6a16482010-12-04 03:47:34 +00004948 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004949
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004950 case SK_ConstructorInitialization:
Richard Smithf4bb8d02012-07-05 08:39:21 +00004951 case SK_ListConstructorCall:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004952 case SK_ZeroInitialization:
4953 break;
Douglas Gregor20093b42009-12-09 23:02:17 +00004954 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004955
4956 // Walk through the computed steps for the initialization sequence,
Douglas Gregor20093b42009-12-09 23:02:17 +00004957 // performing the specified conversions along the way.
Douglas Gregor16006c92009-12-16 18:50:27 +00004958 bool ConstructorInitRequiresZeroInit = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00004959 for (step_iterator Step = step_begin(), StepEnd = step_end();
4960 Step != StepEnd; ++Step) {
4961 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00004962 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004963
John Wiegley429bb272011-04-08 18:41:53 +00004964 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004965
Douglas Gregor20093b42009-12-09 23:02:17 +00004966 switch (Step->Kind) {
4967 case SK_ResolveAddressOfOverloadedFunction:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004968 // Overload resolution determined which function invoke; update the
Douglas Gregor20093b42009-12-09 23:02:17 +00004969 // initializer to reflect that choice.
John Wiegley429bb272011-04-08 18:41:53 +00004970 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
John McCallb697e082010-05-06 18:15:07 +00004971 S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004972 CurInit = S.FixOverloadedFunctionReference(CurInit,
John McCall6bb80172010-03-30 21:47:33 +00004973 Step->Function.FoundDecl,
John McCall9aa472c2010-03-19 07:35:19 +00004974 Step->Function.Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00004975 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004976
Douglas Gregor20093b42009-12-09 23:02:17 +00004977 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00004978 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00004979 case SK_CastDerivedToBaseLValue: {
4980 // We have a derived-to-base cast that produces either an rvalue or an
4981 // lvalue. Perform that cast.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004982
John McCallf871d0c2010-08-07 06:22:56 +00004983 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00004984
Douglas Gregor20093b42009-12-09 23:02:17 +00004985 // Casts to inaccessible base classes are allowed with C-style casts.
4986 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
4987 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
John Wiegley429bb272011-04-08 18:41:53 +00004988 CurInit.get()->getLocStart(),
4989 CurInit.get()->getSourceRange(),
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00004990 &BasePath, IgnoreBaseAccess))
John McCallf312b1e2010-08-26 23:41:50 +00004991 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004992
Douglas Gregor6fb745b2010-05-13 16:44:06 +00004993 if (S.BasePathInvolvesVirtualBase(BasePath)) {
4994 QualType T = SourceType;
4995 if (const PointerType *Pointer = T->getAs<PointerType>())
4996 T = Pointer->getPointeeType();
4997 if (const RecordType *RecordTy = T->getAs<RecordType>())
John Wiegley429bb272011-04-08 18:41:53 +00004998 S.MarkVTableUsed(CurInit.get()->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00004999 cast<CXXRecordDecl>(RecordTy->getDecl()));
5000 }
5001
John McCall5baba9d2010-08-25 10:28:54 +00005002 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005003 Step->Kind == SK_CastDerivedToBaseLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005004 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005005 (Step->Kind == SK_CastDerivedToBaseXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005006 VK_XValue :
5007 VK_RValue);
John McCallf871d0c2010-08-07 06:22:56 +00005008 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5009 Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005010 CK_DerivedToBase,
John McCall5baba9d2010-08-25 10:28:54 +00005011 CurInit.get(),
5012 &BasePath, VK));
Douglas Gregor20093b42009-12-09 23:02:17 +00005013 break;
5014 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005015
Douglas Gregor20093b42009-12-09 23:02:17 +00005016 case SK_BindReference:
John Wiegley429bb272011-04-08 18:41:53 +00005017 if (FieldDecl *BitField = CurInit.get()->getBitField()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00005018 // References cannot bind to bit fields (C++ [dcl.init.ref]p5).
5019 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
Douglas Gregord6542d82009-12-22 15:35:07 +00005020 << Entity.getType().isVolatileQualified()
Douglas Gregor20093b42009-12-09 23:02:17 +00005021 << BitField->getDeclName()
John Wiegley429bb272011-04-08 18:41:53 +00005022 << CurInit.get()->getSourceRange();
Douglas Gregor20093b42009-12-09 23:02:17 +00005023 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
John McCallf312b1e2010-08-26 23:41:50 +00005024 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005025 }
Anders Carlssona6fe0bf2010-01-29 02:47:33 +00005026
John Wiegley429bb272011-04-08 18:41:53 +00005027 if (CurInit.get()->refersToVectorElement()) {
John McCall41593e32010-02-02 19:02:38 +00005028 // References cannot bind to vector elements.
Anders Carlsson09380262010-01-31 17:18:49 +00005029 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5030 << Entity.getType().isVolatileQualified()
John Wiegley429bb272011-04-08 18:41:53 +00005031 << CurInit.get()->getSourceRange();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005032 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005033 return ExprError();
Anders Carlsson09380262010-01-31 17:18:49 +00005034 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005035
Douglas Gregor20093b42009-12-09 23:02:17 +00005036 // Reference binding does not have any corresponding ASTs.
5037
5038 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005039 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005040 return ExprError();
Anders Carlsson3aba0932010-01-31 18:34:51 +00005041
Douglas Gregor20093b42009-12-09 23:02:17 +00005042 break;
Anders Carlsson3aba0932010-01-31 18:34:51 +00005043
Douglas Gregor20093b42009-12-09 23:02:17 +00005044 case SK_BindReferenceToTemporary:
5045 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005046 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005047 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005048
Douglas Gregor03e80032011-06-21 17:03:29 +00005049 // Materialize the temporary into memory.
Douglas Gregorb4b7b502011-06-22 15:05:02 +00005050 CurInit = new (S.Context) MaterializeTemporaryExpr(
5051 Entity.getType().getNonReferenceType(),
5052 CurInit.get(),
Douglas Gregor03e80032011-06-21 17:03:29 +00005053 Entity.getType()->isLValueReferenceType());
Douglas Gregord7b23162011-06-22 16:12:01 +00005054
5055 // If we're binding to an Objective-C object that has lifetime, we
5056 // need cleanups.
David Blaikie4e4d0842012-03-11 07:00:24 +00005057 if (S.getLangOpts().ObjCAutoRefCount &&
Douglas Gregord7b23162011-06-22 16:12:01 +00005058 CurInit.get()->getType()->isObjCLifetimeType())
5059 S.ExprNeedsCleanups = true;
5060
Douglas Gregor20093b42009-12-09 23:02:17 +00005061 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005062
Douglas Gregor523d46a2010-04-18 07:40:54 +00005063 case SK_ExtraneousCopyToTemporary:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005064 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
Douglas Gregor523d46a2010-04-18 07:40:54 +00005065 /*IsExtraneousCopy=*/true);
5066 break;
5067
Douglas Gregor20093b42009-12-09 23:02:17 +00005068 case SK_UserConversion: {
5069 // We have a user-defined conversion that invokes either a constructor
5070 // or a conversion function.
John McCalldaa8e4e2010-11-15 09:13:47 +00005071 CastKind CastKind;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005072 bool IsCopy = false;
John McCall9aa472c2010-03-19 07:35:19 +00005073 FunctionDecl *Fn = Step->Function.Function;
5074 DeclAccessPair FoundFn = Step->Function.FoundDecl;
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005075 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005076 bool CreatedObject = false;
John McCallb13b7372010-02-01 03:16:54 +00005077 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00005078 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005079 SmallVector<Expr*, 8> ConstructorArgs;
John Wiegley429bb272011-04-08 18:41:53 +00005080 SourceLocation Loc = CurInit.get()->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00005081 CurInit.release(); // Ownership transferred into MultiExprArg, below.
John McCallb13b7372010-02-01 03:16:54 +00005082
Douglas Gregor20093b42009-12-09 23:02:17 +00005083 // Determine the arguments required to actually perform the constructor
5084 // call.
John Wiegley429bb272011-04-08 18:41:53 +00005085 Expr *Arg = CurInit.get();
Douglas Gregor20093b42009-12-09 23:02:17 +00005086 if (S.CompleteConstructorCall(Constructor,
John Wiegley429bb272011-04-08 18:41:53 +00005087 MultiExprArg(&Arg, 1),
Douglas Gregor20093b42009-12-09 23:02:17 +00005088 Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005089 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005090
Richard Smithf2e4dfc2012-02-11 19:22:50 +00005091 // Build an expression that constructs a temporary.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005092 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005093 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005094 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005095 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005096 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005097 CXXConstructExpr::CK_Complete,
5098 SourceRange());
Douglas Gregor20093b42009-12-09 23:02:17 +00005099 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005100 return ExprError();
John McCallb13b7372010-02-01 03:16:54 +00005101
Anders Carlsson9a68a672010-04-21 18:47:17 +00005102 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
John McCall9aa472c2010-03-19 07:35:19 +00005103 FoundFn.getAccess());
John McCallb697e082010-05-06 18:15:07 +00005104 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005105
John McCall2de56d12010-08-25 11:45:40 +00005106 CastKind = CK_ConstructorConversion;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005107 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5108 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5109 S.IsDerivedFrom(SourceType, Class))
5110 IsCopy = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005111
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005112 CreatedObject = true;
Douglas Gregor20093b42009-12-09 23:02:17 +00005113 } else {
5114 // Build a call to the conversion function.
John McCallb13b7372010-02-01 03:16:54 +00005115 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
John Wiegley429bb272011-04-08 18:41:53 +00005116 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), 0,
John McCall9aa472c2010-03-19 07:35:19 +00005117 FoundFn);
John McCallb697e082010-05-06 18:15:07 +00005118 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005119
5120 // FIXME: Should we move this initialization into a separate
Douglas Gregor20093b42009-12-09 23:02:17 +00005121 // derived-to-base conversion? I believe the answer is "no", because
5122 // we don't want to turn off access control here for c-style casts.
John Wiegley429bb272011-04-08 18:41:53 +00005123 ExprResult CurInitExprRes =
5124 S.PerformObjectArgumentInitialization(CurInit.take(), /*Qualifier=*/0,
5125 FoundFn, Conversion);
5126 if(CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005127 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005128 CurInit = CurInitExprRes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005129
Douglas Gregor20093b42009-12-09 23:02:17 +00005130 // Build the actual call to the conversion function.
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005131 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5132 HadMultipleCandidates);
Douglas Gregor20093b42009-12-09 23:02:17 +00005133 if (CurInit.isInvalid() || !CurInit.get())
John McCallf312b1e2010-08-26 23:41:50 +00005134 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005135
John McCall2de56d12010-08-25 11:45:40 +00005136 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005137
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005138 CreatedObject = Conversion->getResultType()->isRecordType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005139 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005140
Sebastian Redl3b802322011-07-14 19:07:55 +00005141 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
Abramo Bagnara960809e2011-11-16 22:46:05 +00005142 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
5143
5144 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
John Wiegley429bb272011-04-08 18:41:53 +00005145 QualType T = CurInit.get()->getType();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005146 if (const RecordType *Record = T->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005147 CXXDestructorDecl *Destructor
Douglas Gregordb89f282010-07-01 22:47:18 +00005148 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
John Wiegley429bb272011-04-08 18:41:53 +00005149 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005150 S.PDiag(diag::err_access_dtor_temp) << T);
Eli Friedman5f2987c2012-02-02 03:46:19 +00005151 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
John Wiegley429bb272011-04-08 18:41:53 +00005152 S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart());
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005153 }
5154 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005155
John McCallf871d0c2010-08-07 06:22:56 +00005156 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
John Wiegley429bb272011-04-08 18:41:53 +00005157 CurInit.get()->getType(),
5158 CastKind, CurInit.get(), 0,
Eli Friedman104be6f2011-09-27 01:11:35 +00005159 CurInit.get()->getValueKind()));
Abramo Bagnara960809e2011-11-16 22:46:05 +00005160 if (MaybeBindToTemp)
5161 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Douglas Gregor2f599792010-04-02 18:24:57 +00005162 if (RequiresCopy)
Douglas Gregor523d46a2010-04-18 07:40:54 +00005163 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005164 CurInit, /*IsExtraneousCopy=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00005165 break;
5166 }
Sebastian Redl906082e2010-07-20 04:20:21 +00005167
Douglas Gregor20093b42009-12-09 23:02:17 +00005168 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005169 case SK_QualificationConversionXValue:
5170 case SK_QualificationConversionRValue: {
Douglas Gregor20093b42009-12-09 23:02:17 +00005171 // Perform a qualification conversion; these can never go wrong.
John McCall5baba9d2010-08-25 10:28:54 +00005172 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005173 Step->Kind == SK_QualificationConversionLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005174 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005175 (Step->Kind == SK_QualificationConversionXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005176 VK_XValue :
5177 VK_RValue);
John Wiegley429bb272011-04-08 18:41:53 +00005178 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK);
Douglas Gregor20093b42009-12-09 23:02:17 +00005179 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00005180 }
5181
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005182 case SK_ConversionSequence: {
John McCallf85e1932011-06-15 23:02:42 +00005183 Sema::CheckedConversionKind CCK
5184 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
5185 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
Richard Smithc8d7f582011-11-29 22:48:16 +00005186 : Kind.isExplicitCast()? Sema::CCK_OtherCast
John McCallf85e1932011-06-15 23:02:42 +00005187 : Sema::CCK_ImplicitConversion;
John Wiegley429bb272011-04-08 18:41:53 +00005188 ExprResult CurInitExprRes =
5189 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
John McCallf85e1932011-06-15 23:02:42 +00005190 getAssignmentAction(Entity), CCK);
John Wiegley429bb272011-04-08 18:41:53 +00005191 if (CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005192 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005193 CurInit = CurInitExprRes;
Douglas Gregor20093b42009-12-09 23:02:17 +00005194 break;
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005195 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005196
Douglas Gregord87b61f2009-12-10 17:56:55 +00005197 case SK_ListInitialization: {
John Wiegley429bb272011-04-08 18:41:53 +00005198 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005199 // Hack: We must pass *ResultType if available in order to set the type
5200 // of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
5201 // But in 'const X &x = {1, 2, 3};' we're supposed to initialize a
5202 // temporary, not a reference, so we should pass Ty.
5203 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
5204 // Since this step is never used for a reference directly, we explicitly
5205 // unwrap references here and rewrap them afterwards.
5206 // We also need to create a InitializeTemporary entity for this.
5207 QualType Ty = ResultType ? ResultType->getNonReferenceType() : Step->Type;
Sebastian Redlcbf82092012-03-07 16:10:45 +00005208 bool IsTemporary = Entity.getType()->isReferenceType();
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005209 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
5210 InitListChecker PerformInitList(S, IsTemporary ? TempEntity : Entity,
5211 InitList, Ty, /*VerifyOnly=*/false,
Sebastian Redl168319c2012-02-12 16:37:24 +00005212 Kind.getKind() != InitializationKind::IK_DirectList ||
Richard Smith80ad52f2013-01-02 11:42:31 +00005213 !S.getLangOpts().CPlusPlus11);
Sebastian Redl14b0c192011-09-24 17:48:00 +00005214 if (PerformInitList.HadError())
John McCallf312b1e2010-08-26 23:41:50 +00005215 return ExprError();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005216
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005217 if (ResultType) {
5218 if ((*ResultType)->isRValueReferenceType())
5219 Ty = S.Context.getRValueReferenceType(Ty);
5220 else if ((*ResultType)->isLValueReferenceType())
5221 Ty = S.Context.getLValueReferenceType(Ty,
5222 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
5223 *ResultType = Ty;
5224 }
5225
5226 InitListExpr *StructuredInitList =
5227 PerformInitList.getFullyStructuredList();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005228 CurInit.release();
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005229 CurInit = S.Owned(StructuredInitList);
Douglas Gregord87b61f2009-12-10 17:56:55 +00005230 break;
5231 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00005232
Sebastian Redl10f04a62011-12-22 14:44:04 +00005233 case SK_ListConstructorCall: {
Sebastian Redl168319c2012-02-12 16:37:24 +00005234 // When an initializer list is passed for a parameter of type "reference
5235 // to object", we don't get an EK_Temporary entity, but instead an
5236 // EK_Parameter entity with reference type.
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005237 // FIXME: This is a hack. What we really should do is create a user
5238 // conversion step for this case, but this makes it considerably more
5239 // complicated. For now, this will do.
Sebastian Redl168319c2012-02-12 16:37:24 +00005240 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
5241 Entity.getType().getNonReferenceType());
5242 bool UseTemporary = Entity.getType()->isReferenceType();
Richard Smithf4bb8d02012-07-05 08:39:21 +00005243 assert(Args.size() == 1 && "expected a single argument for list init");
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005244 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Richard Smith03544fc2012-04-19 06:58:00 +00005245 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
5246 << InitList->getSourceRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005247 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
Sebastian Redl168319c2012-02-12 16:37:24 +00005248 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
5249 Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005250 Kind, Arg, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005251 ConstructorInitRequiresZeroInit,
5252 /*IsListInitialization*/ true);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005253 break;
5254 }
Sebastian Redl8713d4e2011-09-24 17:47:52 +00005255
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005256 case SK_UnwrapInitList:
5257 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0));
5258 break;
5259
5260 case SK_RewrapInitList: {
5261 Expr *E = CurInit.take();
5262 InitListExpr *Syntactic = Step->WrappingSyntacticList;
5263 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00005264 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005265 ILE->setSyntacticForm(Syntactic);
5266 ILE->setType(E->getType());
5267 ILE->setValueKind(E->getValueKind());
5268 CurInit = S.Owned(ILE);
5269 break;
5270 }
5271
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005272 case SK_ConstructorInitialization: {
5273 // When an initializer list is passed for a parameter of type "reference
5274 // to object", we don't get an EK_Temporary entity, but instead an
5275 // EK_Parameter entity with reference type.
5276 // FIXME: This is a hack. What we really should do is create a user
5277 // conversion step for this case, but this makes it considerably more
5278 // complicated. For now, this will do.
5279 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
5280 Entity.getType().getNonReferenceType());
5281 bool UseTemporary = Entity.getType()->isReferenceType();
5282 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity
5283 : Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005284 Kind, Args, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005285 ConstructorInitRequiresZeroInit,
5286 /*IsListInitialization*/ false);
Douglas Gregor51c56d62009-12-14 20:49:26 +00005287 break;
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005288 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005289
Douglas Gregor71d17402009-12-15 00:01:57 +00005290 case SK_ZeroInitialization: {
Douglas Gregor16006c92009-12-16 18:50:27 +00005291 step_iterator NextStep = Step;
5292 ++NextStep;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005293 if (NextStep != StepEnd &&
Richard Smithf4bb8d02012-07-05 08:39:21 +00005294 (NextStep->Kind == SK_ConstructorInitialization ||
5295 NextStep->Kind == SK_ListConstructorCall)) {
Douglas Gregor16006c92009-12-16 18:50:27 +00005296 // The need for zero-initialization is recorded directly into
5297 // the call to the object's constructor within the next step.
5298 ConstructorInitRequiresZeroInit = true;
5299 } else if (Kind.getKind() == InitializationKind::IK_Value &&
David Blaikie4e4d0842012-03-11 07:00:24 +00005300 S.getLangOpts().CPlusPlus &&
Douglas Gregor16006c92009-12-16 18:50:27 +00005301 !Kind.isImplicitValueInit()) {
Douglas Gregorab6677e2010-09-08 00:15:04 +00005302 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5303 if (!TSInfo)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005304 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
Douglas Gregorab6677e2010-09-08 00:15:04 +00005305 Kind.getRange().getBegin());
5306
5307 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr(
5308 TSInfo->getType().getNonLValueExprType(S.Context),
5309 TSInfo,
Douglas Gregor71d17402009-12-15 00:01:57 +00005310 Kind.getRange().getEnd()));
Douglas Gregor16006c92009-12-16 18:50:27 +00005311 } else {
Douglas Gregor71d17402009-12-15 00:01:57 +00005312 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
Douglas Gregor16006c92009-12-16 18:50:27 +00005313 }
Douglas Gregor71d17402009-12-15 00:01:57 +00005314 break;
5315 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005316
5317 case SK_CAssignment: {
John Wiegley429bb272011-04-08 18:41:53 +00005318 QualType SourceType = CurInit.get()->getType();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005319 ExprResult Result = CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005320 Sema::AssignConvertType ConvTy =
John Wiegley429bb272011-04-08 18:41:53 +00005321 S.CheckSingleAssignmentConstraints(Step->Type, Result);
5322 if (Result.isInvalid())
5323 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005324 CurInit = Result;
Douglas Gregoraa037312009-12-22 07:24:36 +00005325
5326 // If this is a call, allow conversion to a transparent union.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005327 ExprResult CurInitExprRes = CurInit;
Douglas Gregoraa037312009-12-22 07:24:36 +00005328 if (ConvTy != Sema::Compatible &&
5329 Entity.getKind() == InitializedEntity::EK_Parameter &&
John Wiegley429bb272011-04-08 18:41:53 +00005330 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
Douglas Gregoraa037312009-12-22 07:24:36 +00005331 == Sema::Compatible)
5332 ConvTy = Sema::Compatible;
John Wiegley429bb272011-04-08 18:41:53 +00005333 if (CurInitExprRes.isInvalid())
5334 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005335 CurInit = CurInitExprRes;
Douglas Gregoraa037312009-12-22 07:24:36 +00005336
Douglas Gregora41a8c52010-04-22 00:20:18 +00005337 bool Complained;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005338 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
5339 Step->Type, SourceType,
John Wiegley429bb272011-04-08 18:41:53 +00005340 CurInit.get(),
Douglas Gregora41a8c52010-04-22 00:20:18 +00005341 getAssignmentAction(Entity),
5342 &Complained)) {
5343 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005344 return ExprError();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005345 } else if (Complained)
5346 PrintInitLocationNote(S, Entity);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005347 break;
5348 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005349
5350 case SK_StringInit: {
5351 QualType Ty = Step->Type;
John Wiegley429bb272011-04-08 18:41:53 +00005352 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
John McCallfef8b342011-02-21 07:57:55 +00005353 S.Context.getAsArrayType(Ty), S);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005354 break;
5355 }
Douglas Gregor569c3162010-08-07 11:51:51 +00005356
5357 case SK_ObjCObjectConversion:
John Wiegley429bb272011-04-08 18:41:53 +00005358 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005359 CK_ObjCObjectLValueCast,
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00005360 CurInit.get()->getValueKind());
Douglas Gregor569c3162010-08-07 11:51:51 +00005361 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005362
5363 case SK_ArrayInit:
5364 // Okay: we checked everything before creating this step. Note that
5365 // this is a GNU extension.
5366 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
John Wiegley429bb272011-04-08 18:41:53 +00005367 << Step->Type << CurInit.get()->getType()
5368 << CurInit.get()->getSourceRange();
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005369
5370 // If the destination type is an incomplete array type, update the
5371 // type accordingly.
5372 if (ResultType) {
5373 if (const IncompleteArrayType *IncompleteDest
5374 = S.Context.getAsIncompleteArrayType(Step->Type)) {
5375 if (const ConstantArrayType *ConstantSource
John Wiegley429bb272011-04-08 18:41:53 +00005376 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005377 *ResultType = S.Context.getConstantArrayType(
5378 IncompleteDest->getElementType(),
5379 ConstantSource->getSize(),
5380 ArrayType::Normal, 0);
5381 }
5382 }
5383 }
John McCallf85e1932011-06-15 23:02:42 +00005384 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005385
Richard Smith0f163e92012-02-15 22:38:09 +00005386 case SK_ParenthesizedArrayInit:
5387 // Okay: we checked everything before creating this step. Note that
5388 // this is a GNU extension.
5389 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
5390 << CurInit.get()->getSourceRange();
5391 break;
5392
John McCallf85e1932011-06-15 23:02:42 +00005393 case SK_PassByIndirectCopyRestore:
5394 case SK_PassByIndirectRestore:
5395 checkIndirectCopyRestoreSource(S, CurInit.get());
5396 CurInit = S.Owned(new (S.Context)
5397 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type,
5398 Step->Kind == SK_PassByIndirectCopyRestore));
5399 break;
5400
5401 case SK_ProduceObjCObject:
5402 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
John McCall33e56f32011-09-10 06:18:15 +00005403 CK_ARCProduceObject,
John McCallf85e1932011-06-15 23:02:42 +00005404 CurInit.take(), 0, VK_RValue));
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005405 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00005406
5407 case SK_StdInitializerList: {
5408 QualType Dest = Step->Type;
5409 QualType E;
5410 bool Success = S.isStdInitializerList(Dest, &E);
5411 (void)Success;
5412 assert(Success && "Destination type changed?");
Sebastian Redl28357452012-03-05 19:35:43 +00005413
5414 // If the element type has a destructor, check it.
5415 if (CXXRecordDecl *RD = E->getAsCXXRecordDecl()) {
5416 if (!RD->hasIrrelevantDestructor()) {
5417 if (CXXDestructorDecl *Destructor = S.LookupDestructor(RD)) {
5418 S.MarkFunctionReferenced(Kind.getLocation(), Destructor);
5419 S.CheckDestructorAccess(Kind.getLocation(), Destructor,
5420 S.PDiag(diag::err_access_dtor_temp) << E);
5421 S.DiagnoseUseOfDecl(Destructor, Kind.getLocation());
5422 }
5423 }
5424 }
5425
Sebastian Redl2b916b82012-01-17 22:49:42 +00005426 InitListExpr *ILE = cast<InitListExpr>(CurInit.take());
Richard Smith03544fc2012-04-19 06:58:00 +00005427 S.Diag(ILE->getExprLoc(), diag::warn_cxx98_compat_initializer_list_init)
5428 << ILE->getSourceRange();
Sebastian Redl2b916b82012-01-17 22:49:42 +00005429 unsigned NumInits = ILE->getNumInits();
5430 SmallVector<Expr*, 16> Converted(NumInits);
5431 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
5432 S.Context.getConstantArrayType(E,
5433 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
5434 NumInits),
5435 ArrayType::Normal, 0));
5436 InitializedEntity Element =InitializedEntity::InitializeElement(S.Context,
5437 0, HiddenArray);
5438 for (unsigned i = 0; i < NumInits; ++i) {
5439 Element.setElementIndex(i);
5440 ExprResult Init = S.Owned(ILE->getInit(i));
5441 ExprResult Res = S.PerformCopyInitialization(Element,
5442 Init.get()->getExprLoc(),
5443 Init);
5444 assert(!Res.isInvalid() && "Result changed since try phase.");
5445 Converted[i] = Res.take();
5446 }
5447 InitListExpr *Semantic = new (S.Context)
5448 InitListExpr(S.Context, ILE->getLBraceLoc(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00005449 Converted, ILE->getRBraceLoc());
Sebastian Redl2b916b82012-01-17 22:49:42 +00005450 Semantic->setSyntacticForm(ILE);
5451 Semantic->setType(Dest);
Sebastian Redl32cf1f22012-02-17 08:42:25 +00005452 Semantic->setInitializesStdInitializerList();
Sebastian Redl2b916b82012-01-17 22:49:42 +00005453 CurInit = S.Owned(Semantic);
5454 break;
5455 }
Douglas Gregor20093b42009-12-09 23:02:17 +00005456 }
5457 }
John McCall15d7d122010-11-11 03:21:53 +00005458
5459 // Diagnose non-fatal problems with the completed initialization.
5460 if (Entity.getKind() == InitializedEntity::EK_Member &&
5461 cast<FieldDecl>(Entity.getDecl())->isBitField())
5462 S.CheckBitFieldInitialization(Kind.getLocation(),
5463 cast<FieldDecl>(Entity.getDecl()),
5464 CurInit.get());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005465
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005466 return CurInit;
Douglas Gregor20093b42009-12-09 23:02:17 +00005467}
5468
Richard Smithd5bc8672012-12-08 02:01:17 +00005469/// Somewhere within T there is an uninitialized reference subobject.
5470/// Dig it out and diagnose it.
5471bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T) {
5472 if (T->isReferenceType()) {
5473 S.Diag(Loc, diag::err_reference_without_init)
5474 << T.getNonReferenceType();
5475 return true;
5476 }
5477
5478 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
5479 if (!RD || !RD->hasUninitializedReferenceMember())
5480 return false;
5481
5482 for (CXXRecordDecl::field_iterator FI = RD->field_begin(),
5483 FE = RD->field_end(); FI != FE; ++FI) {
5484 if (FI->isUnnamedBitfield())
5485 continue;
5486
5487 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
5488 S.Diag(Loc, diag::note_value_initialization_here) << RD;
5489 return true;
5490 }
5491 }
5492
5493 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
5494 BE = RD->bases_end();
5495 BI != BE; ++BI) {
5496 if (DiagnoseUninitializedReference(S, BI->getLocStart(), BI->getType())) {
5497 S.Diag(Loc, diag::note_value_initialization_here) << RD;
5498 return true;
5499 }
5500 }
5501
5502 return false;
5503}
5504
5505
Douglas Gregor20093b42009-12-09 23:02:17 +00005506//===----------------------------------------------------------------------===//
5507// Diagnose initialization failures
5508//===----------------------------------------------------------------------===//
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005509bool InitializationSequence::Diagnose(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00005510 const InitializedEntity &Entity,
5511 const InitializationKind &Kind,
5512 Expr **Args, unsigned NumArgs) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00005513 if (!Failed())
Douglas Gregor20093b42009-12-09 23:02:17 +00005514 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005515
Douglas Gregord6542d82009-12-22 15:35:07 +00005516 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005517 switch (Failure) {
5518 case FK_TooManyInitsForReference:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00005519 // FIXME: Customize for the initialized entity?
Richard Smithd5bc8672012-12-08 02:01:17 +00005520 if (NumArgs == 0) {
5521 // Dig out the reference subobject which is uninitialized and diagnose it.
5522 // If this is value-initialization, this could be nested some way within
5523 // the target type.
5524 assert(Kind.getKind() == InitializationKind::IK_Value ||
5525 DestType->isReferenceType());
5526 bool Diagnosed =
5527 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
5528 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
5529 (void)Diagnosed;
5530 } else // FIXME: diagnostic below could be better!
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00005531 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
5532 << SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd());
Douglas Gregor20093b42009-12-09 23:02:17 +00005533 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005534
Douglas Gregor20093b42009-12-09 23:02:17 +00005535 case FK_ArrayNeedsInitList:
5536 case FK_ArrayNeedsInitListOrStringLiteral:
5537 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list)
5538 << (Failure == FK_ArrayNeedsInitListOrStringLiteral);
5539 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005540
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005541 case FK_ArrayTypeMismatch:
5542 case FK_NonConstantArrayInit:
5543 S.Diag(Kind.getLocation(),
5544 (Failure == FK_ArrayTypeMismatch
5545 ? diag::err_array_init_different_type
5546 : diag::err_array_init_non_constant_array))
5547 << DestType.getNonReferenceType()
5548 << Args[0]->getType()
5549 << Args[0]->getSourceRange();
5550 break;
5551
John McCall73076432012-01-05 00:13:19 +00005552 case FK_VariableLengthArrayHasInitializer:
5553 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
5554 << Args[0]->getSourceRange();
5555 break;
5556
John McCall6bb80172010-03-30 21:47:33 +00005557 case FK_AddressOfOverloadFailed: {
5558 DeclAccessPair Found;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005559 S.ResolveAddressOfOverloadedFunction(Args[0],
Douglas Gregor20093b42009-12-09 23:02:17 +00005560 DestType.getNonReferenceType(),
John McCall6bb80172010-03-30 21:47:33 +00005561 true,
5562 Found);
Douglas Gregor20093b42009-12-09 23:02:17 +00005563 break;
John McCall6bb80172010-03-30 21:47:33 +00005564 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005565
Douglas Gregor20093b42009-12-09 23:02:17 +00005566 case FK_ReferenceInitOverloadFailed:
Douglas Gregor4a520a22009-12-14 17:27:33 +00005567 case FK_UserConversionOverloadFailed:
Douglas Gregor20093b42009-12-09 23:02:17 +00005568 switch (FailedOverloadResult) {
5569 case OR_Ambiguous:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005570 if (Failure == FK_UserConversionOverloadFailed)
5571 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
5572 << Args[0]->getType() << DestType
5573 << Args[0]->getSourceRange();
5574 else
5575 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
5576 << DestType << Args[0]->getType()
5577 << Args[0]->getSourceRange();
5578
Ahmed Charles13a140c2012-02-25 11:00:22 +00005579 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates,
5580 llvm::makeArrayRef(Args, NumArgs));
Douglas Gregor20093b42009-12-09 23:02:17 +00005581 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005582
Douglas Gregor20093b42009-12-09 23:02:17 +00005583 case OR_No_Viable_Function:
5584 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
5585 << Args[0]->getType() << DestType.getNonReferenceType()
5586 << Args[0]->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00005587 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates,
5588 llvm::makeArrayRef(Args, NumArgs));
Douglas Gregor20093b42009-12-09 23:02:17 +00005589 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005590
Douglas Gregor20093b42009-12-09 23:02:17 +00005591 case OR_Deleted: {
5592 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
5593 << Args[0]->getType() << DestType.getNonReferenceType()
5594 << Args[0]->getSourceRange();
5595 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00005596 OverloadingResult Ovl
Douglas Gregor8fcc5162010-09-12 08:07:23 +00005597 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
5598 true);
Douglas Gregor20093b42009-12-09 23:02:17 +00005599 if (Ovl == OR_Deleted) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00005600 S.NoteDeletedFunction(Best->Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00005601 } else {
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00005602 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregor20093b42009-12-09 23:02:17 +00005603 }
5604 break;
5605 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005606
Douglas Gregor20093b42009-12-09 23:02:17 +00005607 case OR_Success:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00005608 llvm_unreachable("Conversion did not fail!");
Douglas Gregor20093b42009-12-09 23:02:17 +00005609 }
5610 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005611
Douglas Gregor20093b42009-12-09 23:02:17 +00005612 case FK_NonConstLValueReferenceBindingToTemporary:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005613 if (isa<InitListExpr>(Args[0])) {
5614 S.Diag(Kind.getLocation(),
5615 diag::err_lvalue_reference_bind_to_initlist)
5616 << DestType.getNonReferenceType().isVolatileQualified()
5617 << DestType.getNonReferenceType()
5618 << Args[0]->getSourceRange();
5619 break;
5620 }
5621 // Intentional fallthrough
5622
Douglas Gregor20093b42009-12-09 23:02:17 +00005623 case FK_NonConstLValueReferenceBindingToUnrelated:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005624 S.Diag(Kind.getLocation(),
Douglas Gregor20093b42009-12-09 23:02:17 +00005625 Failure == FK_NonConstLValueReferenceBindingToTemporary
5626 ? diag::err_lvalue_reference_bind_to_temporary
5627 : diag::err_lvalue_reference_bind_to_unrelated)
Douglas Gregoref06e242010-01-29 19:39:15 +00005628 << DestType.getNonReferenceType().isVolatileQualified()
Douglas Gregor20093b42009-12-09 23:02:17 +00005629 << DestType.getNonReferenceType()
5630 << Args[0]->getType()
5631 << Args[0]->getSourceRange();
5632 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005633
Douglas Gregor20093b42009-12-09 23:02:17 +00005634 case FK_RValueReferenceBindingToLValue:
5635 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
Douglas Gregorfb5d7ef2011-01-21 01:04:33 +00005636 << DestType.getNonReferenceType() << Args[0]->getType()
Douglas Gregor20093b42009-12-09 23:02:17 +00005637 << Args[0]->getSourceRange();
5638 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005639
Douglas Gregor20093b42009-12-09 23:02:17 +00005640 case FK_ReferenceInitDropsQualifiers:
5641 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
5642 << DestType.getNonReferenceType()
5643 << Args[0]->getType()
5644 << Args[0]->getSourceRange();
5645 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005646
Douglas Gregor20093b42009-12-09 23:02:17 +00005647 case FK_ReferenceInitFailed:
5648 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
5649 << DestType.getNonReferenceType()
John McCall7eb0a9e2010-11-24 05:12:34 +00005650 << Args[0]->isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00005651 << Args[0]->getType()
5652 << Args[0]->getSourceRange();
Douglas Gregor926df6c2011-06-11 01:09:30 +00005653 if (DestType.getNonReferenceType()->isObjCObjectPointerType() &&
5654 Args[0]->getType()->isObjCObjectPointerType())
5655 S.EmitRelatedResultTypeNote(Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00005656 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005657
Douglas Gregor1be8eec2011-02-19 21:32:49 +00005658 case FK_ConversionFailed: {
5659 QualType FromType = Args[0]->getType();
Richard Trieu6efd4c52011-11-23 22:32:32 +00005660 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005661 << (int)Entity.getKind()
Douglas Gregor20093b42009-12-09 23:02:17 +00005662 << DestType
John McCall7eb0a9e2010-11-24 05:12:34 +00005663 << Args[0]->isLValue()
Douglas Gregor1be8eec2011-02-19 21:32:49 +00005664 << FromType
Douglas Gregor20093b42009-12-09 23:02:17 +00005665 << Args[0]->getSourceRange();
Richard Trieu6efd4c52011-11-23 22:32:32 +00005666 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
5667 S.Diag(Kind.getLocation(), PDiag);
Douglas Gregor926df6c2011-06-11 01:09:30 +00005668 if (DestType.getNonReferenceType()->isObjCObjectPointerType() &&
5669 Args[0]->getType()->isObjCObjectPointerType())
5670 S.EmitRelatedResultTypeNote(Args[0]);
Douglas Gregord87b61f2009-12-10 17:56:55 +00005671 break;
Douglas Gregor1be8eec2011-02-19 21:32:49 +00005672 }
John Wiegley429bb272011-04-08 18:41:53 +00005673
5674 case FK_ConversionFromPropertyFailed:
5675 // No-op. This error has already been reported.
5676 break;
5677
Douglas Gregord87b61f2009-12-10 17:56:55 +00005678 case FK_TooManyInitsForScalar: {
Douglas Gregor99a2e602009-12-16 01:38:02 +00005679 SourceRange R;
5680
5681 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
Douglas Gregor19311e72010-09-08 21:40:08 +00005682 R = SourceRange(InitList->getInit(0)->getLocEnd(),
Douglas Gregor99a2e602009-12-16 01:38:02 +00005683 InitList->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005684 else
Douglas Gregor19311e72010-09-08 21:40:08 +00005685 R = SourceRange(Args[0]->getLocEnd(), Args[NumArgs - 1]->getLocEnd());
Douglas Gregord87b61f2009-12-10 17:56:55 +00005686
Douglas Gregor19311e72010-09-08 21:40:08 +00005687 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin()));
5688 if (Kind.isCStyleOrFunctionalCast())
5689 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
5690 << R;
5691 else
5692 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
5693 << /*scalar=*/2 << R;
Douglas Gregord87b61f2009-12-10 17:56:55 +00005694 break;
5695 }
5696
5697 case FK_ReferenceBindingToInitList:
5698 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
5699 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
5700 break;
5701
5702 case FK_InitListBadDestinationType:
5703 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
5704 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
5705 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005706
Sebastian Redlcf15cef2011-12-22 18:58:38 +00005707 case FK_ListConstructorOverloadFailed:
Douglas Gregor51c56d62009-12-14 20:49:26 +00005708 case FK_ConstructorOverloadFailed: {
5709 SourceRange ArgsRange;
5710 if (NumArgs)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005711 ArgsRange = SourceRange(Args[0]->getLocStart(),
Douglas Gregor51c56d62009-12-14 20:49:26 +00005712 Args[NumArgs - 1]->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005713
Sebastian Redlcf15cef2011-12-22 18:58:38 +00005714 if (Failure == FK_ListConstructorOverloadFailed) {
5715 assert(NumArgs == 1 && "List construction from other than 1 argument.");
5716 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
5717 Args = InitList->getInits();
5718 NumArgs = InitList->getNumInits();
5719 }
5720
Douglas Gregor51c56d62009-12-14 20:49:26 +00005721 // FIXME: Using "DestType" for the entity we're printing is probably
5722 // bad.
5723 switch (FailedOverloadResult) {
5724 case OR_Ambiguous:
5725 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
5726 << DestType << ArgsRange;
John McCall120d63c2010-08-24 20:38:10 +00005727 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates,
Ahmed Charles13a140c2012-02-25 11:00:22 +00005728 llvm::makeArrayRef(Args, NumArgs));
Douglas Gregor51c56d62009-12-14 20:49:26 +00005729 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005730
Douglas Gregor51c56d62009-12-14 20:49:26 +00005731 case OR_No_Viable_Function:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00005732 if (Kind.getKind() == InitializationKind::IK_Default &&
5733 (Entity.getKind() == InitializedEntity::EK_Base ||
5734 Entity.getKind() == InitializedEntity::EK_Member) &&
5735 isa<CXXConstructorDecl>(S.CurContext)) {
5736 // This is implicit default initialization of a member or
5737 // base within a constructor. If no viable function was
5738 // found, notify the user that she needs to explicitly
5739 // initialize this base/member.
5740 CXXConstructorDecl *Constructor
5741 = cast<CXXConstructorDecl>(S.CurContext);
5742 if (Entity.getKind() == InitializedEntity::EK_Base) {
5743 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
5744 << Constructor->isImplicit()
5745 << S.Context.getTypeDeclType(Constructor->getParent())
5746 << /*base=*/0
5747 << Entity.getType();
5748
5749 RecordDecl *BaseDecl
5750 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
5751 ->getDecl();
5752 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
5753 << S.Context.getTagDeclType(BaseDecl);
5754 } else {
5755 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
5756 << Constructor->isImplicit()
5757 << S.Context.getTypeDeclType(Constructor->getParent())
5758 << /*member=*/1
5759 << Entity.getName();
5760 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
5761
5762 if (const RecordType *Record
5763 = Entity.getType()->getAs<RecordType>())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005764 S.Diag(Record->getDecl()->getLocation(),
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00005765 diag::note_previous_decl)
5766 << S.Context.getTagDeclType(Record->getDecl());
5767 }
5768 break;
5769 }
5770
Douglas Gregor51c56d62009-12-14 20:49:26 +00005771 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
5772 << DestType << ArgsRange;
Ahmed Charles13a140c2012-02-25 11:00:22 +00005773 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates,
5774 llvm::makeArrayRef(Args, NumArgs));
Douglas Gregor51c56d62009-12-14 20:49:26 +00005775 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005776
Douglas Gregor51c56d62009-12-14 20:49:26 +00005777 case OR_Deleted: {
Douglas Gregor51c56d62009-12-14 20:49:26 +00005778 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00005779 OverloadingResult Ovl
5780 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Douglas Gregore4e68d42012-02-15 19:33:52 +00005781 if (Ovl != OR_Deleted) {
5782 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
5783 << true << DestType << ArgsRange;
Douglas Gregor51c56d62009-12-14 20:49:26 +00005784 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregore4e68d42012-02-15 19:33:52 +00005785 break;
Douglas Gregor51c56d62009-12-14 20:49:26 +00005786 }
Douglas Gregore4e68d42012-02-15 19:33:52 +00005787
5788 // If this is a defaulted or implicitly-declared function, then
5789 // it was implicitly deleted. Make it clear that the deletion was
5790 // implicit.
Richard Smith6c4c36c2012-03-30 20:53:28 +00005791 if (S.isImplicitlyDeleted(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00005792 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
Richard Smith6c4c36c2012-03-30 20:53:28 +00005793 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00005794 << DestType << ArgsRange;
Richard Smith6c4c36c2012-03-30 20:53:28 +00005795 else
5796 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
5797 << true << DestType << ArgsRange;
5798
5799 S.NoteDeletedFunction(Best->Function);
Douglas Gregor51c56d62009-12-14 20:49:26 +00005800 break;
5801 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005802
Douglas Gregor51c56d62009-12-14 20:49:26 +00005803 case OR_Success:
5804 llvm_unreachable("Conversion did not fail!");
Douglas Gregor51c56d62009-12-14 20:49:26 +00005805 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00005806 }
David Blaikie9fdefb32012-01-17 08:24:58 +00005807 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005808
Douglas Gregor99a2e602009-12-16 01:38:02 +00005809 case FK_DefaultInitOfConst:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00005810 if (Entity.getKind() == InitializedEntity::EK_Member &&
5811 isa<CXXConstructorDecl>(S.CurContext)) {
5812 // This is implicit default-initialization of a const member in
5813 // a constructor. Complain that it needs to be explicitly
5814 // initialized.
5815 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
5816 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
5817 << Constructor->isImplicit()
5818 << S.Context.getTypeDeclType(Constructor->getParent())
5819 << /*const=*/1
5820 << Entity.getName();
5821 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
5822 << Entity.getName();
5823 } else {
5824 S.Diag(Kind.getLocation(), diag::err_default_init_const)
5825 << DestType << (bool)DestType->getAs<RecordType>();
5826 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00005827 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005828
Sebastian Redl8713d4e2011-09-24 17:47:52 +00005829 case FK_Incomplete:
Douglas Gregor69a30b82012-04-10 20:43:46 +00005830 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
Sebastian Redl8713d4e2011-09-24 17:47:52 +00005831 diag::err_init_incomplete_type);
5832 break;
5833
Sebastian Redl14b0c192011-09-24 17:48:00 +00005834 case FK_ListInitializationFailed: {
5835 // Run the init list checker again to emit diagnostics.
5836 InitListExpr* InitList = cast<InitListExpr>(Args[0]);
5837 QualType DestType = Entity.getType();
5838 InitListChecker DiagnoseInitList(S, Entity, InitList,
Sebastian Redlc2235182011-10-16 18:19:28 +00005839 DestType, /*VerifyOnly=*/false,
Sebastian Redl168319c2012-02-12 16:37:24 +00005840 Kind.getKind() != InitializationKind::IK_DirectList ||
Richard Smith80ad52f2013-01-02 11:42:31 +00005841 !S.getLangOpts().CPlusPlus11);
Sebastian Redl14b0c192011-09-24 17:48:00 +00005842 assert(DiagnoseInitList.HadError() &&
5843 "Inconsistent init list check result.");
5844 break;
5845 }
John McCall5acb0c92011-10-17 18:40:02 +00005846
5847 case FK_PlaceholderType: {
5848 // FIXME: Already diagnosed!
5849 break;
5850 }
Sebastian Redl2b916b82012-01-17 22:49:42 +00005851
5852 case FK_InitListElementCopyFailure: {
5853 // Try to perform all copies again.
5854 InitListExpr* InitList = cast<InitListExpr>(Args[0]);
5855 unsigned NumInits = InitList->getNumInits();
5856 QualType DestType = Entity.getType();
5857 QualType E;
5858 bool Success = S.isStdInitializerList(DestType, &E);
5859 (void)Success;
5860 assert(Success && "Where did the std::initializer_list go?");
5861 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(
5862 S.Context.getConstantArrayType(E,
5863 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
5864 NumInits),
5865 ArrayType::Normal, 0));
5866 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context,
5867 0, HiddenArray);
5868 // Show at most 3 errors. Otherwise, you'd get a lot of errors for errors
5869 // where the init list type is wrong, e.g.
5870 // std::initializer_list<void*> list = { 1, 2, 3, 4, 5, 6, 7, 8 };
5871 // FIXME: Emit a note if we hit the limit?
5872 int ErrorCount = 0;
5873 for (unsigned i = 0; i < NumInits && ErrorCount < 3; ++i) {
5874 Element.setElementIndex(i);
5875 ExprResult Init = S.Owned(InitList->getInit(i));
5876 if (S.PerformCopyInitialization(Element, Init.get()->getExprLoc(), Init)
5877 .isInvalid())
5878 ++ErrorCount;
5879 }
5880 break;
5881 }
Sebastian Redl70e24fc2012-04-01 19:54:59 +00005882
5883 case FK_ExplicitConstructor: {
5884 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
5885 << Args[0]->getSourceRange();
5886 OverloadCandidateSet::iterator Best;
5887 OverloadingResult Ovl
5888 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Matt Beaumont-Gaye7d0bbf2012-04-02 19:05:35 +00005889 (void)Ovl;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00005890 assert(Ovl == OR_Success && "Inconsistent overload resolution");
5891 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
5892 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
5893 break;
5894 }
Douglas Gregor20093b42009-12-09 23:02:17 +00005895 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005896
Douglas Gregora41a8c52010-04-22 00:20:18 +00005897 PrintInitLocationNote(S, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00005898 return true;
5899}
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005900
Chris Lattner5f9e2722011-07-23 10:55:15 +00005901void InitializationSequence::dump(raw_ostream &OS) const {
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005902 switch (SequenceKind) {
5903 case FailedSequence: {
5904 OS << "Failed sequence: ";
5905 switch (Failure) {
5906 case FK_TooManyInitsForReference:
5907 OS << "too many initializers for reference";
5908 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005909
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005910 case FK_ArrayNeedsInitList:
5911 OS << "array requires initializer list";
5912 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005913
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005914 case FK_ArrayNeedsInitListOrStringLiteral:
5915 OS << "array requires initializer list or string literal";
5916 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005917
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005918 case FK_ArrayTypeMismatch:
5919 OS << "array type mismatch";
5920 break;
5921
5922 case FK_NonConstantArrayInit:
5923 OS << "non-constant array initializer";
5924 break;
5925
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005926 case FK_AddressOfOverloadFailed:
5927 OS << "address of overloaded function failed";
5928 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005929
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005930 case FK_ReferenceInitOverloadFailed:
5931 OS << "overload resolution for reference initialization failed";
5932 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005933
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005934 case FK_NonConstLValueReferenceBindingToTemporary:
5935 OS << "non-const lvalue reference bound to temporary";
5936 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005937
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005938 case FK_NonConstLValueReferenceBindingToUnrelated:
5939 OS << "non-const lvalue reference bound to unrelated type";
5940 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005941
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005942 case FK_RValueReferenceBindingToLValue:
5943 OS << "rvalue reference bound to an lvalue";
5944 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005945
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005946 case FK_ReferenceInitDropsQualifiers:
5947 OS << "reference initialization drops qualifiers";
5948 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005949
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005950 case FK_ReferenceInitFailed:
5951 OS << "reference initialization failed";
5952 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005953
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005954 case FK_ConversionFailed:
5955 OS << "conversion failed";
5956 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005957
John Wiegley429bb272011-04-08 18:41:53 +00005958 case FK_ConversionFromPropertyFailed:
5959 OS << "conversion from property failed";
5960 break;
5961
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005962 case FK_TooManyInitsForScalar:
5963 OS << "too many initializers for scalar";
5964 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005965
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005966 case FK_ReferenceBindingToInitList:
5967 OS << "referencing binding to initializer list";
5968 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005969
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005970 case FK_InitListBadDestinationType:
5971 OS << "initializer list for non-aggregate, non-scalar type";
5972 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005973
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005974 case FK_UserConversionOverloadFailed:
5975 OS << "overloading failed for user-defined conversion";
5976 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005977
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005978 case FK_ConstructorOverloadFailed:
5979 OS << "constructor overloading failed";
5980 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005981
Douglas Gregorde4b1d82010-01-29 19:14:02 +00005982 case FK_DefaultInitOfConst:
5983 OS << "default initialization of a const variable";
5984 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005985
Douglas Gregor72a43bb2010-05-20 22:12:02 +00005986 case FK_Incomplete:
5987 OS << "initialization of incomplete type";
5988 break;
Sebastian Redl8713d4e2011-09-24 17:47:52 +00005989
5990 case FK_ListInitializationFailed:
Sebastian Redl14b0c192011-09-24 17:48:00 +00005991 OS << "list initialization checker failure";
John McCall5acb0c92011-10-17 18:40:02 +00005992 break;
5993
John McCall73076432012-01-05 00:13:19 +00005994 case FK_VariableLengthArrayHasInitializer:
5995 OS << "variable length array has an initializer";
5996 break;
5997
John McCall5acb0c92011-10-17 18:40:02 +00005998 case FK_PlaceholderType:
5999 OS << "initializer expression isn't contextually valid";
6000 break;
Nick Lewyckyb0c6c332011-12-22 20:21:32 +00006001
6002 case FK_ListConstructorOverloadFailed:
6003 OS << "list constructor overloading failed";
6004 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006005
6006 case FK_InitListElementCopyFailure:
6007 OS << "copy construction of initializer list element failed";
6008 break;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006009
6010 case FK_ExplicitConstructor:
6011 OS << "list copy initialization chose explicit constructor";
6012 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006013 }
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006014 OS << '\n';
6015 return;
6016 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006017
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006018 case DependentSequence:
Sebastian Redl7491c492011-06-05 13:59:11 +00006019 OS << "Dependent sequence\n";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006020 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006021
Sebastian Redl7491c492011-06-05 13:59:11 +00006022 case NormalSequence:
6023 OS << "Normal sequence: ";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006024 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006025 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006026
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006027 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6028 if (S != step_begin()) {
6029 OS << " -> ";
6030 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006031
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006032 switch (S->Kind) {
6033 case SK_ResolveAddressOfOverloadedFunction:
6034 OS << "resolve address of overloaded function";
6035 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006036
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006037 case SK_CastDerivedToBaseRValue:
6038 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6039 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006040
Sebastian Redl906082e2010-07-20 04:20:21 +00006041 case SK_CastDerivedToBaseXValue:
6042 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
6043 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006044
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006045 case SK_CastDerivedToBaseLValue:
6046 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
6047 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006048
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006049 case SK_BindReference:
6050 OS << "bind reference to lvalue";
6051 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006052
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006053 case SK_BindReferenceToTemporary:
6054 OS << "bind reference to a temporary";
6055 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006056
Douglas Gregor523d46a2010-04-18 07:40:54 +00006057 case SK_ExtraneousCopyToTemporary:
6058 OS << "extraneous C++03 copy to temporary";
6059 break;
6060
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006061 case SK_UserConversion:
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006062 OS << "user-defined conversion via " << *S->Function.Function;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006063 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006064
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006065 case SK_QualificationConversionRValue:
6066 OS << "qualification conversion (rvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006067 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006068
Sebastian Redl906082e2010-07-20 04:20:21 +00006069 case SK_QualificationConversionXValue:
6070 OS << "qualification conversion (xvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006071 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006072
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006073 case SK_QualificationConversionLValue:
6074 OS << "qualification conversion (lvalue)";
6075 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006076
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006077 case SK_ConversionSequence:
6078 OS << "implicit conversion sequence (";
6079 S->ICS->DebugPrint(); // FIXME: use OS
6080 OS << ")";
6081 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006082
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006083 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006084 OS << "list aggregate initialization";
6085 break;
6086
6087 case SK_ListConstructorCall:
6088 OS << "list initialization via constructor";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006089 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006090
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006091 case SK_UnwrapInitList:
6092 OS << "unwrap reference initializer list";
6093 break;
6094
6095 case SK_RewrapInitList:
6096 OS << "rewrap reference initializer list";
6097 break;
6098
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006099 case SK_ConstructorInitialization:
6100 OS << "constructor initialization";
6101 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006102
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006103 case SK_ZeroInitialization:
6104 OS << "zero initialization";
6105 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006106
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006107 case SK_CAssignment:
6108 OS << "C assignment";
6109 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006110
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006111 case SK_StringInit:
6112 OS << "string initialization";
6113 break;
Douglas Gregor569c3162010-08-07 11:51:51 +00006114
6115 case SK_ObjCObjectConversion:
6116 OS << "Objective-C object conversion";
6117 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006118
6119 case SK_ArrayInit:
6120 OS << "array initialization";
6121 break;
John McCallf85e1932011-06-15 23:02:42 +00006122
Richard Smith0f163e92012-02-15 22:38:09 +00006123 case SK_ParenthesizedArrayInit:
6124 OS << "parenthesized array initialization";
6125 break;
6126
John McCallf85e1932011-06-15 23:02:42 +00006127 case SK_PassByIndirectCopyRestore:
6128 OS << "pass by indirect copy and restore";
6129 break;
6130
6131 case SK_PassByIndirectRestore:
6132 OS << "pass by indirect restore";
6133 break;
6134
6135 case SK_ProduceObjCObject:
6136 OS << "Objective-C object retension";
6137 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006138
6139 case SK_StdInitializerList:
6140 OS << "std::initializer_list from initializer list";
6141 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006142 }
6143 }
6144}
6145
6146void InitializationSequence::dump() const {
6147 dump(llvm::errs());
6148}
6149
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006150static void DiagnoseNarrowingInInitList(Sema &S, InitializationSequence &Seq,
6151 QualType EntityType,
6152 const Expr *PreInit,
6153 const Expr *PostInit) {
6154 if (Seq.step_begin() == Seq.step_end() || PreInit->isValueDependent())
6155 return;
6156
6157 // A narrowing conversion can only appear as the final implicit conversion in
6158 // an initialization sequence.
6159 const InitializationSequence::Step &LastStep = Seq.step_end()[-1];
6160 if (LastStep.Kind != InitializationSequence::SK_ConversionSequence)
6161 return;
6162
6163 const ImplicitConversionSequence &ICS = *LastStep.ICS;
6164 const StandardConversionSequence *SCS = 0;
6165 switch (ICS.getKind()) {
6166 case ImplicitConversionSequence::StandardConversion:
6167 SCS = &ICS.Standard;
6168 break;
6169 case ImplicitConversionSequence::UserDefinedConversion:
6170 SCS = &ICS.UserDefined.After;
6171 break;
6172 case ImplicitConversionSequence::AmbiguousConversion:
6173 case ImplicitConversionSequence::EllipsisConversion:
6174 case ImplicitConversionSequence::BadConversion:
6175 return;
6176 }
6177
6178 // Determine the type prior to the narrowing conversion. If a conversion
6179 // operator was used, this may be different from both the type of the entity
6180 // and of the pre-initialization expression.
6181 QualType PreNarrowingType = PreInit->getType();
6182 if (Seq.step_begin() + 1 != Seq.step_end())
6183 PreNarrowingType = Seq.step_end()[-2].Type;
6184
6185 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
6186 APValue ConstantValue;
Richard Smithf6028062012-03-23 23:55:39 +00006187 QualType ConstantType;
6188 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
6189 ConstantType)) {
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006190 case NK_Not_Narrowing:
6191 // No narrowing occurred.
6192 return;
6193
6194 case NK_Type_Narrowing:
6195 // This was a floating-to-integer conversion, which is always considered a
6196 // narrowing conversion even if the value is a constant and can be
6197 // represented exactly as an integer.
6198 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006199 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006200 diag::warn_init_list_type_narrowing
6201 : S.isSFINAEContext()?
6202 diag::err_init_list_type_narrowing_sfinae
6203 : diag::err_init_list_type_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006204 << PostInit->getSourceRange()
6205 << PreNarrowingType.getLocalUnqualifiedType()
6206 << EntityType.getLocalUnqualifiedType();
6207 break;
6208
6209 case NK_Constant_Narrowing:
6210 // A constant value was narrowed.
6211 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006212 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006213 diag::warn_init_list_constant_narrowing
6214 : S.isSFINAEContext()?
6215 diag::err_init_list_constant_narrowing_sfinae
6216 : diag::err_init_list_constant_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006217 << PostInit->getSourceRange()
Richard Smithf6028062012-03-23 23:55:39 +00006218 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
Jeffrey Yasskin99061492011-08-29 15:59:37 +00006219 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006220 break;
6221
6222 case NK_Variable_Narrowing:
6223 // A variable's value may have been narrowed.
6224 S.Diag(PostInit->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +00006225 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11?
Douglas Gregorf3c82c52012-01-23 15:29:33 +00006226 diag::warn_init_list_variable_narrowing
6227 : S.isSFINAEContext()?
6228 diag::err_init_list_variable_narrowing_sfinae
6229 : diag::err_init_list_variable_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006230 << PostInit->getSourceRange()
6231 << PreNarrowingType.getLocalUnqualifiedType()
Jeffrey Yasskin99061492011-08-29 15:59:37 +00006232 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006233 break;
6234 }
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006235
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00006236 SmallString<128> StaticCast;
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006237 llvm::raw_svector_ostream OS(StaticCast);
6238 OS << "static_cast<";
6239 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
6240 // It's important to use the typedef's name if there is one so that the
6241 // fixit doesn't break code using types like int64_t.
6242 //
6243 // FIXME: This will break if the typedef requires qualification. But
6244 // getQualifiedNameAsString() includes non-machine-parsable components.
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006245 OS << *TT->getDecl();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006246 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
David Blaikie4e4d0842012-03-11 07:00:24 +00006247 OS << BT->getName(S.getLangOpts());
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006248 else {
6249 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
6250 // with a broken cast.
6251 return;
6252 }
6253 OS << ">(";
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006254 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override)
6255 << PostInit->getSourceRange()
6256 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006257 << FixItHint::CreateInsertion(
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006258 S.getPreprocessor().getLocForEndOfToken(PostInit->getLocEnd()), ")");
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006259}
6260
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006261//===----------------------------------------------------------------------===//
6262// Initialization helper functions
6263//===----------------------------------------------------------------------===//
Sean Hunt2be7e902011-05-12 22:46:29 +00006264bool
6265Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
6266 ExprResult Init) {
6267 if (Init.isInvalid())
6268 return false;
6269
6270 Expr *InitE = Init.get();
6271 assert(InitE && "No initialization expression");
6272
Douglas Gregor3c394c52012-07-31 22:15:04 +00006273 InitializationKind Kind
6274 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
Sean Hunt2be7e902011-05-12 22:46:29 +00006275 InitializationSequence Seq(*this, Entity, Kind, &InitE, 1);
Sebastian Redl383616c2011-06-05 12:23:28 +00006276 return !Seq.Failed();
Sean Hunt2be7e902011-05-12 22:46:29 +00006277}
6278
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006279ExprResult
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006280Sema::PerformCopyInitialization(const InitializedEntity &Entity,
6281 SourceLocation EqualLoc,
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006282 ExprResult Init,
Douglas Gregored878af2012-02-24 23:56:31 +00006283 bool TopLevelOfInitList,
6284 bool AllowExplicit) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006285 if (Init.isInvalid())
6286 return ExprError();
6287
John McCall15d7d122010-11-11 03:21:53 +00006288 Expr *InitE = Init.get();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006289 assert(InitE && "No initialization expression?");
6290
6291 if (EqualLoc.isInvalid())
6292 EqualLoc = InitE->getLocStart();
6293
6294 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
Douglas Gregored878af2012-02-24 23:56:31 +00006295 EqualLoc,
6296 AllowExplicit);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006297 InitializationSequence Seq(*this, Entity, Kind, &InitE, 1);
6298 Init.release();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00006299
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006300 ExprResult Result = Seq.Perform(*this, Entity, Kind, MultiExprArg(&InitE, 1));
6301
6302 if (!Result.isInvalid() && TopLevelOfInitList)
6303 DiagnoseNarrowingInInitList(*this, Seq, Entity.getType(),
6304 InitE, Result.get());
6305
6306 return Result;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006307}