blob: 382901667ed269dd1bf1b027faf88773078e3df8 [file] [log] [blame]
Steve Naroff0cca7492008-05-01 22:18:59 +00001//===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
Sebastian Redl5d3d41d2011-09-24 17:47:39 +000010// This file implements semantic analysis for initializers.
Chris Lattnerdd8e0062009-02-24 22:27:37 +000011//
Steve Naroff0cca7492008-05-01 22:18:59 +000012//===----------------------------------------------------------------------===//
13
Douglas Gregore737f502010-08-12 20:07:10 +000014#include "clang/Sema/Initialization.h"
Steve Naroff0cca7492008-05-01 22:18:59 +000015#include "clang/AST/ASTContext.h"
John McCall7cd088e2010-08-24 07:21:54 +000016#include "clang/AST/DeclObjC.h"
Anders Carlsson2078bb92009-05-27 16:10:08 +000017#include "clang/AST/ExprCXX.h"
Chris Lattner79e079d2009-02-24 23:10:27 +000018#include "clang/AST/ExprObjC.h"
Douglas Gregord6542d82009-12-22 15:35:07 +000019#include "clang/AST/TypeLoc.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000020#include "clang/Lex/Preprocessor.h"
21#include "clang/Sema/Designator.h"
22#include "clang/Sema/Lookup.h"
23#include "clang/Sema/SemaInternal.h"
Sebastian Redl2b916b82012-01-17 22:49:42 +000024#include "llvm/ADT/APInt.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000025#include "llvm/ADT/SmallString.h"
Douglas Gregor20093b42009-12-09 23:02:17 +000026#include "llvm/Support/ErrorHandling.h"
Jeffrey Yasskin19159132011-07-26 23:20:30 +000027#include "llvm/Support/raw_ostream.h"
Douglas Gregorc34ee5e2009-01-29 00:45:39 +000028#include <map>
Douglas Gregor05c13a32009-01-22 00:58:24 +000029using namespace clang;
Steve Naroff0cca7492008-05-01 22:18:59 +000030
Chris Lattnerdd8e0062009-02-24 22:27:37 +000031//===----------------------------------------------------------------------===//
32// Sema Initialization Checking
33//===----------------------------------------------------------------------===//
34
Hans Wennborg0ff50742013-05-15 11:03:04 +000035/// \brief Check whether T is compatible with a wide character type (wchar_t,
36/// char16_t or char32_t).
37static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38 if (Context.typesAreCompatible(Context.getWideCharType(), T))
39 return true;
40 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41 return Context.typesAreCompatible(Context.Char16Ty, T) ||
42 Context.typesAreCompatible(Context.Char32Ty, T);
43 }
44 return false;
45}
46
47enum StringInitFailureKind {
48 SIF_None,
49 SIF_NarrowStringIntoWideChar,
50 SIF_WideStringIntoChar,
51 SIF_IncompatWideStringIntoWideChar,
52 SIF_Other
53};
54
55/// \brief Check whether the array of type AT can be initialized by the Init
56/// expression by means of string initialization. Returns SIF_None if so,
57/// otherwise returns a StringInitFailureKind that describes why the
58/// initialization would not work.
59static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
60 ASTContext &Context) {
Eli Friedman8718a6a2009-05-29 18:22:49 +000061 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
Hans Wennborg0ff50742013-05-15 11:03:04 +000062 return SIF_Other;
Eli Friedman8718a6a2009-05-29 18:22:49 +000063
Chris Lattner8879e3b2009-02-26 23:26:43 +000064 // See if this is a string literal or @encode.
65 Init = Init->IgnoreParens();
Mike Stump1eb44332009-09-09 15:08:12 +000066
Chris Lattner8879e3b2009-02-26 23:26:43 +000067 // Handle @encode, which is a narrow string.
68 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
Hans Wennborg0ff50742013-05-15 11:03:04 +000069 return SIF_None;
Chris Lattner8879e3b2009-02-26 23:26:43 +000070
71 // Otherwise we can only handle string literals.
72 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
Hans Wennborg0ff50742013-05-15 11:03:04 +000073 if (SL == 0)
74 return SIF_Other;
Eli Friedmanbb6415c2009-05-31 10:54:53 +000075
Hans Wennborg0ff50742013-05-15 11:03:04 +000076 const QualType ElemTy =
77 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
Douglas Gregor5cee1192011-07-27 05:40:30 +000078
79 switch (SL->getKind()) {
80 case StringLiteral::Ascii:
81 case StringLiteral::UTF8:
82 // char array can be initialized with a narrow string.
83 // Only allow char x[] = "foo"; not char x[] = L"foo";
Hans Wennborg0ff50742013-05-15 11:03:04 +000084 if (ElemTy->isCharType())
85 return SIF_None;
86 if (IsWideCharCompatible(ElemTy, Context))
87 return SIF_NarrowStringIntoWideChar;
88 return SIF_Other;
89 // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
90 // "An array with element type compatible with a qualified or unqualified
91 // version of wchar_t, char16_t, or char32_t may be initialized by a wide
92 // string literal with the corresponding encoding prefix (L, u, or U,
93 // respectively), optionally enclosed in braces.
Douglas Gregor5cee1192011-07-27 05:40:30 +000094 case StringLiteral::UTF16:
Hans Wennborg0ff50742013-05-15 11:03:04 +000095 if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
96 return SIF_None;
97 if (ElemTy->isCharType())
98 return SIF_WideStringIntoChar;
99 if (IsWideCharCompatible(ElemTy, Context))
100 return SIF_IncompatWideStringIntoWideChar;
101 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000102 case StringLiteral::UTF32:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000103 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
104 return SIF_None;
105 if (ElemTy->isCharType())
106 return SIF_WideStringIntoChar;
107 if (IsWideCharCompatible(ElemTy, Context))
108 return SIF_IncompatWideStringIntoWideChar;
109 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000110 case StringLiteral::Wide:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000111 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
112 return SIF_None;
113 if (ElemTy->isCharType())
114 return SIF_WideStringIntoChar;
115 if (IsWideCharCompatible(ElemTy, Context))
116 return SIF_IncompatWideStringIntoWideChar;
117 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000118 }
Mike Stump1eb44332009-09-09 15:08:12 +0000119
Douglas Gregor5cee1192011-07-27 05:40:30 +0000120 llvm_unreachable("missed a StringLiteral kind?");
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000121}
122
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000123static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
124 ASTContext &Context) {
John McCallce6c9b72011-02-21 07:22:22 +0000125 const ArrayType *arrayType = Context.getAsArrayType(declType);
Hans Wennborg0ff50742013-05-15 11:03:04 +0000126 if (!arrayType)
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000127 return SIF_Other;
128 return IsStringInit(init, arrayType, Context);
John McCallce6c9b72011-02-21 07:22:22 +0000129}
130
Richard Smith30ae1ed2013-05-05 16:40:13 +0000131/// Update the type of a string literal, including any surrounding parentheses,
132/// to match the type of the object which it is initializing.
133static void updateStringLiteralType(Expr *E, QualType Ty) {
Richard Smith27f9cf32013-05-06 00:35:47 +0000134 while (true) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000135 E->setType(Ty);
Richard Smith27f9cf32013-05-06 00:35:47 +0000136 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
137 break;
138 else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
139 E = PE->getSubExpr();
140 else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
141 E = UO->getSubExpr();
142 else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
143 E = GSE->getResultExpr();
144 else
145 llvm_unreachable("unexpected expr in string literal init");
Richard Smith30ae1ed2013-05-05 16:40:13 +0000146 }
Richard Smith30ae1ed2013-05-05 16:40:13 +0000147}
148
John McCallfef8b342011-02-21 07:57:55 +0000149static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
150 Sema &S) {
Chris Lattner79e079d2009-02-24 23:10:27 +0000151 // Get the length of the string as parsed.
152 uint64_t StrLength =
153 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
154
Mike Stump1eb44332009-09-09 15:08:12 +0000155
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000156 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000157 // C99 6.7.8p14. We have an array of character type with unknown size
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000158 // being initialized to a string literal.
Benjamin Kramer65263b42012-08-04 17:00:46 +0000159 llvm::APInt ConstVal(32, StrLength);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000160 // Return a new array type (C99 6.7.8p22).
John McCall46a617a2009-10-16 00:14:28 +0000161 DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
162 ConstVal,
163 ArrayType::Normal, 0);
Richard Smith30ae1ed2013-05-05 16:40:13 +0000164 updateStringLiteralType(Str, DeclT);
Chris Lattner19da8cd2009-02-24 23:01:39 +0000165 return;
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000166 }
Mike Stump1eb44332009-09-09 15:08:12 +0000167
Eli Friedman8718a6a2009-05-29 18:22:49 +0000168 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Mike Stump1eb44332009-09-09 15:08:12 +0000169
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000170 // We have an array of character type with known size. However,
Eli Friedman8718a6a2009-05-29 18:22:49 +0000171 // the size may be smaller or larger than the string we are initializing.
172 // FIXME: Avoid truncation for 64-bit length strings.
David Blaikie4e4d0842012-03-11 07:00:24 +0000173 if (S.getLangOpts().CPlusPlus) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000174 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
Anders Carlssonb8fc45f2011-04-14 00:41:11 +0000175 // For Pascal strings it's OK to strip off the terminating null character,
176 // so the example below is valid:
177 //
178 // unsigned char a[2] = "\pa";
179 if (SL->isPascal())
180 StrLength--;
181 }
182
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000183 // [dcl.init.string]p2
184 if (StrLength > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000185 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000186 diag::err_initializer_string_for_char_array_too_long)
187 << Str->getSourceRange();
188 } else {
189 // C99 6.7.8p14.
190 if (StrLength-1 > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000191 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000192 diag::warn_initializer_string_for_char_array_too_long)
193 << Str->getSourceRange();
194 }
Mike Stump1eb44332009-09-09 15:08:12 +0000195
Eli Friedman8718a6a2009-05-29 18:22:49 +0000196 // Set the type to the actual size that we are initializing. If we have
197 // something like:
198 // char x[1] = "foo";
199 // then this will set the string literal's type to char[1].
Richard Smith30ae1ed2013-05-05 16:40:13 +0000200 updateStringLiteralType(Str, DeclT);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000201}
202
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000203//===----------------------------------------------------------------------===//
204// Semantic checking for initializer lists.
205//===----------------------------------------------------------------------===//
206
Douglas Gregor9e80f722009-01-29 01:05:33 +0000207/// @brief Semantic checking for initializer lists.
208///
209/// The InitListChecker class contains a set of routines that each
210/// handle the initialization of a certain kind of entity, e.g.,
211/// arrays, vectors, struct/union types, scalars, etc. The
212/// InitListChecker itself performs a recursive walk of the subobject
213/// structure of the type to be initialized, while stepping through
214/// the initializer list one element at a time. The IList and Index
215/// parameters to each of the Check* routines contain the active
216/// (syntactic) initializer list and the index into that initializer
217/// list that represents the current initializer. Each routine is
218/// responsible for moving that Index forward as it consumes elements.
219///
220/// Each Check* routine also has a StructuredList/StructuredIndex
Abramo Bagnara63e7d252011-01-27 19:55:10 +0000221/// arguments, which contains the current "structured" (semantic)
Douglas Gregor9e80f722009-01-29 01:05:33 +0000222/// initializer list and the index into that initializer list where we
223/// are copying initializers as we map them over to the semantic
224/// list. Once we have completed our recursive walk of the subobject
225/// structure, we will have constructed a full semantic initializer
226/// list.
227///
228/// C99 designators cause changes in the initializer list traversal,
229/// because they make the initialization "jump" into a specific
230/// subobject and then continue the initialization from that
231/// point. CheckDesignatedInitializer() recursively steps into the
232/// designated subobject and manages backing out the recursion to
233/// initialize the subobjects after the one designated.
Chris Lattner8b419b92009-02-24 22:48:58 +0000234namespace {
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000235class InitListChecker {
Chris Lattner08202542009-02-24 22:50:46 +0000236 Sema &SemaRef;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000237 bool hadError;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000238 bool VerifyOnly; // no diagnostics, no structure building
Benjamin Kramera7894162012-02-23 14:48:40 +0000239 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000240 InitListExpr *FullyStructuredList;
Mike Stump1eb44332009-09-09 15:08:12 +0000241
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000242 void CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000243 InitListExpr *ParentIList, QualType T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000244 unsigned &Index, InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000245 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000246 void CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000247 InitListExpr *IList, QualType &T,
Richard Smithb9bf3122013-09-20 20:10:22 +0000248 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000249 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000250 void CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000251 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000252 bool SubobjectIsDesignatorContext,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000253 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000254 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000255 unsigned &StructuredIndex,
256 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000257 void CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000258 InitListExpr *IList, QualType ElemType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000259 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000260 InitListExpr *StructuredList,
261 unsigned &StructuredIndex);
Eli Friedman0c706c22011-09-19 23:17:44 +0000262 void CheckComplexType(const InitializedEntity &Entity,
263 InitListExpr *IList, QualType DeclType,
264 unsigned &Index,
265 InitListExpr *StructuredList,
266 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000267 void CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000268 InitListExpr *IList, QualType DeclType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000269 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000270 InitListExpr *StructuredList,
271 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000272 void CheckReferenceType(const InitializedEntity &Entity,
273 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +0000274 unsigned &Index,
275 InitListExpr *StructuredList,
276 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000277 void CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000278 InitListExpr *IList, QualType DeclType, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000279 InitListExpr *StructuredList,
280 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000281 void CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +0000282 InitListExpr *IList, QualType DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000283 RecordDecl::field_iterator Field,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000284 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000285 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000286 unsigned &StructuredIndex,
287 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000288 void CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +0000289 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000290 llvm::APSInt elementIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000291 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000292 InitListExpr *StructuredList,
293 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000294 bool CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +0000295 InitListExpr *IList, DesignatedInitExpr *DIE,
Douglas Gregor71199712009-04-15 04:56:10 +0000296 unsigned DesigIdx,
Mike Stump1eb44332009-09-09 15:08:12 +0000297 QualType &CurrentObjectType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000298 RecordDecl::field_iterator *NextField,
299 llvm::APSInt *NextElementIndex,
300 unsigned &Index,
301 InitListExpr *StructuredList,
302 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000303 bool FinishSubobjectInit,
304 bool TopLevelObject);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000305 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
306 QualType CurrentObjectType,
307 InitListExpr *StructuredList,
308 unsigned StructuredIndex,
309 SourceRange InitRange);
Douglas Gregor9e80f722009-01-29 01:05:33 +0000310 void UpdateStructuredListElement(InitListExpr *StructuredList,
311 unsigned &StructuredIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000312 Expr *expr);
313 int numArrayElements(QualType DeclType);
314 int numStructUnionElements(QualType DeclType);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000315
Douglas Gregord6d37de2009-12-22 00:05:34 +0000316 void FillInValueInitForField(unsigned Init, FieldDecl *Field,
317 const InitializedEntity &ParentEntity,
318 InitListExpr *ILE, bool &RequiresSecondPass);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000319 void FillInValueInitializations(const InitializedEntity &Entity,
320 InitListExpr *ILE, bool &RequiresSecondPass);
Eli Friedmanf40fd6b2011-08-23 22:24:57 +0000321 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
322 Expr *InitExpr, FieldDecl *Field,
323 bool TopLevelObject);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000324 void CheckValueInitializable(const InitializedEntity &Entity);
325
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000326public:
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000327 InitListChecker(Sema &S, const InitializedEntity &Entity,
Richard Smith40cba902013-06-06 11:41:05 +0000328 InitListExpr *IL, QualType &T, bool VerifyOnly);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000329 bool HadError() { return hadError; }
330
331 // @brief Retrieves the fully-structured initializer list used for
332 // semantic analysis and code generation.
333 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
334};
Chris Lattner8b419b92009-02-24 22:48:58 +0000335} // end anonymous namespace
Chris Lattner68355a52009-01-29 05:10:57 +0000336
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000337void InitListChecker::CheckValueInitializable(const InitializedEntity &Entity) {
338 assert(VerifyOnly &&
339 "CheckValueInitializable is only inteded for verification mode.");
340
341 SourceLocation Loc;
342 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
343 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000344 InitializationSequence InitSeq(SemaRef, Entity, Kind, None);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000345 if (InitSeq.Failed())
346 hadError = true;
347}
348
Douglas Gregord6d37de2009-12-22 00:05:34 +0000349void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
350 const InitializedEntity &ParentEntity,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000351 InitListExpr *ILE,
Douglas Gregord6d37de2009-12-22 00:05:34 +0000352 bool &RequiresSecondPass) {
Daniel Dunbar96a00142012-03-09 18:35:03 +0000353 SourceLocation Loc = ILE->getLocStart();
Douglas Gregord6d37de2009-12-22 00:05:34 +0000354 unsigned NumInits = ILE->getNumInits();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000355 InitializedEntity MemberEntity
Douglas Gregord6d37de2009-12-22 00:05:34 +0000356 = InitializedEntity::InitializeMember(Field, &ParentEntity);
357 if (Init >= NumInits || !ILE->getInit(Init)) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000358 // If there's no explicit initializer but we have a default initializer, use
359 // that. This only happens in C++1y, since classes with default
360 // initializers are not aggregates in C++11.
361 if (Field->hasInClassInitializer()) {
362 Expr *DIE = CXXDefaultInitExpr::Create(SemaRef.Context,
363 ILE->getRBraceLoc(), Field);
364 if (Init < NumInits)
365 ILE->setInit(Init, DIE);
366 else {
367 ILE->updateInit(SemaRef.Context, Init, DIE);
368 RequiresSecondPass = true;
369 }
370 return;
371 }
372
Douglas Gregord6d37de2009-12-22 00:05:34 +0000373 // FIXME: We probably don't need to handle references
374 // specially here, since value-initialization of references is
375 // handled in InitializationSequence.
376 if (Field->getType()->isReferenceType()) {
377 // C++ [dcl.init.aggr]p9:
378 // If an incomplete or empty initializer-list leaves a
379 // member of reference type uninitialized, the program is
380 // ill-formed.
381 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
382 << Field->getType()
383 << ILE->getSyntacticForm()->getSourceRange();
384 SemaRef.Diag(Field->getLocation(),
385 diag::note_uninit_reference_member);
386 hadError = true;
387 return;
388 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000389
Douglas Gregord6d37de2009-12-22 00:05:34 +0000390 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
391 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000392 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000393 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000394 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000395 hadError = true;
396 return;
397 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000398
John McCall60d7b3a2010-08-24 06:29:42 +0000399 ExprResult MemberInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000400 = InitSeq.Perform(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000401 if (MemberInit.isInvalid()) {
402 hadError = true;
403 return;
404 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000405
Douglas Gregord6d37de2009-12-22 00:05:34 +0000406 if (hadError) {
407 // Do nothing
408 } else if (Init < NumInits) {
409 ILE->setInit(Init, MemberInit.takeAs<Expr>());
Sebastian Redl7491c492011-06-05 13:59:11 +0000410 } else if (InitSeq.isConstructorInitialization()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000411 // Value-initialization requires a constructor call, so
412 // extend the initializer list to include the constructor
413 // call and make a note that we'll need to take another pass
414 // through the initializer list.
Ted Kremenek709210f2010-04-13 23:39:13 +0000415 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
Douglas Gregord6d37de2009-12-22 00:05:34 +0000416 RequiresSecondPass = true;
417 }
418 } else if (InitListExpr *InnerILE
419 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000420 FillInValueInitializations(MemberEntity, InnerILE,
421 RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000422}
423
Douglas Gregor4c678342009-01-28 21:54:33 +0000424/// Recursively replaces NULL values within the given initializer list
425/// with expressions that perform value-initialization of the
426/// appropriate type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000427void
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000428InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
429 InitListExpr *ILE,
430 bool &RequiresSecondPass) {
Mike Stump1eb44332009-09-09 15:08:12 +0000431 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
Douglas Gregor930d8b52009-01-30 22:09:00 +0000432 "Should not have void type");
Daniel Dunbar96a00142012-03-09 18:35:03 +0000433 SourceLocation Loc = ILE->getLocStart();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000434 if (ILE->getSyntacticForm())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000435 Loc = ILE->getSyntacticForm()->getLocStart();
Mike Stump1eb44332009-09-09 15:08:12 +0000436
Ted Kremenek6217b802009-07-29 21:53:49 +0000437 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000438 const RecordDecl *RDecl = RType->getDecl();
439 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000440 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
441 Entity, ILE, RequiresSecondPass);
Richard Smithc3bf52c2013-04-20 22:23:05 +0000442 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
443 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700444 for (auto *Field : RDecl->fields()) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000445 if (Field->hasInClassInitializer()) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700446 FillInValueInitForField(0, Field, Entity, ILE, RequiresSecondPass);
Richard Smithc3bf52c2013-04-20 22:23:05 +0000447 break;
448 }
449 }
450 } else {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000451 unsigned Init = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -0700452 for (auto *Field : RDecl->fields()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000453 if (Field->isUnnamedBitfield())
454 continue;
Douglas Gregor4c678342009-01-28 21:54:33 +0000455
Douglas Gregord6d37de2009-12-22 00:05:34 +0000456 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000457 return;
Douglas Gregord6d37de2009-12-22 00:05:34 +0000458
Stephen Hines651f13c2014-04-23 16:59:28 -0700459 FillInValueInitForField(Init, Field, Entity, ILE, RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000460 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000461 return;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000462
Douglas Gregord6d37de2009-12-22 00:05:34 +0000463 ++Init;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000464
Douglas Gregord6d37de2009-12-22 00:05:34 +0000465 // Only look at the first initialization of a union.
Richard Smithc3bf52c2013-04-20 22:23:05 +0000466 if (RDecl->isUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000467 break;
468 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000469 }
470
471 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000472 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000473
474 QualType ElementType;
Mike Stump1eb44332009-09-09 15:08:12 +0000475
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000476 InitializedEntity ElementEntity = Entity;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000477 unsigned NumInits = ILE->getNumInits();
478 unsigned NumElements = NumInits;
Chris Lattner08202542009-02-24 22:50:46 +0000479 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000480 ElementType = AType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000481 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
482 NumElements = CAType->getSize().getZExtValue();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000483 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000484 0, Entity);
John McCall183700f2009-09-21 23:43:11 +0000485 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000486 ElementType = VType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000487 NumElements = VType->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000488 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000489 0, Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000490 } else
Douglas Gregor4c678342009-01-28 21:54:33 +0000491 ElementType = ILE->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000492
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000493
Douglas Gregor87fd7032009-02-02 17:43:21 +0000494 for (unsigned Init = 0; Init != NumElements; ++Init) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000495 if (hadError)
496 return;
497
Anders Carlssond3d824d2010-01-23 04:34:47 +0000498 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
499 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000500 ElementEntity.setElementIndex(Init);
501
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000502 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : 0);
503 if (!InitExpr && !ILE->hasArrayFiller()) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000504 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
505 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000506 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000507 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000508 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, None);
Douglas Gregor87fd7032009-02-02 17:43:21 +0000509 hadError = true;
510 return;
511 }
512
John McCall60d7b3a2010-08-24 06:29:42 +0000513 ExprResult ElementInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000514 = InitSeq.Perform(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000515 if (ElementInit.isInvalid()) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000516 hadError = true;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000517 return;
518 }
519
520 if (hadError) {
521 // Do nothing
522 } else if (Init < NumInits) {
Argyrios Kyrtzidis3e8dc2a2011-04-21 20:03:38 +0000523 // For arrays, just set the expression used for value-initialization
524 // of the "holes" in the array.
525 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
526 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
527 else
528 ILE->setInit(Init, ElementInit.takeAs<Expr>());
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000529 } else {
530 // For arrays, just set the expression used for value-initialization
531 // of the rest of elements and exit.
532 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
533 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
534 return;
535 }
536
Sebastian Redl7491c492011-06-05 13:59:11 +0000537 if (InitSeq.isConstructorInitialization()) {
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000538 // Value-initialization requires a constructor call, so
539 // extend the initializer list to include the constructor
540 // call and make a note that we'll need to take another pass
541 // through the initializer list.
542 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
543 RequiresSecondPass = true;
544 }
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000545 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000546 } else if (InitListExpr *InnerILE
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000547 = dyn_cast_or_null<InitListExpr>(InitExpr))
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000548 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
Douglas Gregor4c678342009-01-28 21:54:33 +0000549 }
550}
551
Chris Lattner68355a52009-01-29 05:10:57 +0000552
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000553InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
Sebastian Redl14b0c192011-09-24 17:48:00 +0000554 InitListExpr *IL, QualType &T,
Richard Smith40cba902013-06-06 11:41:05 +0000555 bool VerifyOnly)
556 : SemaRef(S), VerifyOnly(VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000557 hadError = false;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000558
Richard Smithb9bf3122013-09-20 20:10:22 +0000559 FullyStructuredList =
560 getStructuredSubobjectInit(IL, 0, T, 0, 0, IL->getSourceRange());
561 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000562 /*TopLevelObject=*/true);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000563
Sebastian Redl14b0c192011-09-24 17:48:00 +0000564 if (!hadError && !VerifyOnly) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000565 bool RequiresSecondPass = false;
566 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
Douglas Gregor16006c92009-12-16 18:50:27 +0000567 if (RequiresSecondPass && !hadError)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000568 FillInValueInitializations(Entity, FullyStructuredList,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000569 RequiresSecondPass);
570 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000571}
572
573int InitListChecker::numArrayElements(QualType DeclType) {
Eli Friedman638e1442008-05-25 13:22:35 +0000574 // FIXME: use a proper constant
575 int maxElements = 0x7FFFFFFF;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000576 if (const ConstantArrayType *CAT =
Chris Lattner08202542009-02-24 22:50:46 +0000577 SemaRef.Context.getAsConstantArrayType(DeclType)) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000578 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
579 }
580 return maxElements;
581}
582
583int InitListChecker::numStructUnionElements(QualType DeclType) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000584 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
Douglas Gregor4c678342009-01-28 21:54:33 +0000585 int InitializableMembers = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -0700586 for (const auto *Field : structDecl->fields())
Douglas Gregord61db332011-10-10 17:22:13 +0000587 if (!Field->isUnnamedBitfield())
Douglas Gregor4c678342009-01-28 21:54:33 +0000588 ++InitializableMembers;
Stephen Hines651f13c2014-04-23 16:59:28 -0700589
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000590 if (structDecl->isUnion())
Eli Friedmanf84eda32008-05-25 14:03:31 +0000591 return std::min(InitializableMembers, 1);
592 return InitializableMembers - structDecl->hasFlexibleArrayMember();
Steve Naroff0cca7492008-05-01 22:18:59 +0000593}
594
Richard Smithb9bf3122013-09-20 20:10:22 +0000595/// Check whether the range of the initializer \p ParentIList from element
596/// \p Index onwards can be used to initialize an object of type \p T. Update
597/// \p Index to indicate how many elements of the list were consumed.
598///
599/// This also fills in \p StructuredList, from element \p StructuredIndex
600/// onwards, with the fully-braced, desugared form of the initialization.
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000601void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000602 InitListExpr *ParentIList,
Douglas Gregor4c678342009-01-28 21:54:33 +0000603 QualType T, unsigned &Index,
604 InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000605 unsigned &StructuredIndex) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000606 int maxElements = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000607
Steve Naroff0cca7492008-05-01 22:18:59 +0000608 if (T->isArrayType())
609 maxElements = numArrayElements(T);
Douglas Gregorfb87b892010-04-26 21:31:17 +0000610 else if (T->isRecordType())
Steve Naroff0cca7492008-05-01 22:18:59 +0000611 maxElements = numStructUnionElements(T);
Eli Friedmanb85f7072008-05-19 19:16:24 +0000612 else if (T->isVectorType())
John McCall183700f2009-09-21 23:43:11 +0000613 maxElements = T->getAs<VectorType>()->getNumElements();
Steve Naroff0cca7492008-05-01 22:18:59 +0000614 else
David Blaikieb219cfc2011-09-23 05:06:16 +0000615 llvm_unreachable("CheckImplicitInitList(): Illegal type");
Eli Friedmanb85f7072008-05-19 19:16:24 +0000616
Eli Friedman402256f2008-05-25 13:49:22 +0000617 if (maxElements == 0) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000618 if (!VerifyOnly)
619 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
620 diag::err_implicit_empty_initializer);
Douglas Gregor4c678342009-01-28 21:54:33 +0000621 ++Index;
Eli Friedman402256f2008-05-25 13:49:22 +0000622 hadError = true;
623 return;
624 }
625
Douglas Gregor4c678342009-01-28 21:54:33 +0000626 // Build a structured initializer list corresponding to this subobject.
627 InitListExpr *StructuredSubobjectInitList
Mike Stump1eb44332009-09-09 15:08:12 +0000628 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
629 StructuredIndex,
Daniel Dunbar96a00142012-03-09 18:35:03 +0000630 SourceRange(ParentIList->getInit(Index)->getLocStart(),
Douglas Gregored8a93d2009-03-01 17:12:46 +0000631 ParentIList->getSourceRange().getEnd()));
Douglas Gregor4c678342009-01-28 21:54:33 +0000632 unsigned StructuredSubobjectInitIndex = 0;
Eli Friedmanb85f7072008-05-19 19:16:24 +0000633
Douglas Gregor4c678342009-01-28 21:54:33 +0000634 // Check the element types and build the structural subobject.
Douglas Gregor87fd7032009-02-02 17:43:21 +0000635 unsigned StartIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000636 CheckListElementTypes(Entity, ParentIList, T,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000637 /*SubobjectIsDesignatorContext=*/false, Index,
Mike Stump1eb44332009-09-09 15:08:12 +0000638 StructuredSubobjectInitList,
Eli Friedman629f1182011-08-23 20:17:13 +0000639 StructuredSubobjectInitIndex);
Sebastian Redlc2235182011-10-16 18:19:28 +0000640
Richard Smith40cba902013-06-06 11:41:05 +0000641 if (!VerifyOnly) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000642 StructuredSubobjectInitList->setType(T);
Douglas Gregora6457962009-03-20 00:32:56 +0000643
Sebastian Redlc2235182011-10-16 18:19:28 +0000644 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000645 // Update the structured sub-object initializer so that it's ending
646 // range corresponds with the end of the last initializer it used.
647 if (EndIndex < ParentIList->getNumInits()) {
648 SourceLocation EndLoc
649 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
650 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
651 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000652
Sebastian Redlc2235182011-10-16 18:19:28 +0000653 // Complain about missing braces.
Sebastian Redl14b0c192011-09-24 17:48:00 +0000654 if (T->isArrayType() || T->isRecordType()) {
655 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
Richard Smith40cba902013-06-06 11:41:05 +0000656 diag::warn_missing_braces)
Sebastian Redl14b0c192011-09-24 17:48:00 +0000657 << StructuredSubobjectInitList->getSourceRange()
658 << FixItHint::CreateInsertion(
659 StructuredSubobjectInitList->getLocStart(), "{")
660 << FixItHint::CreateInsertion(
661 SemaRef.PP.getLocForEndOfToken(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000662 StructuredSubobjectInitList->getLocEnd()),
Sebastian Redl14b0c192011-09-24 17:48:00 +0000663 "}");
664 }
Tanya Lattner1e1d3962010-03-07 04:17:15 +0000665 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000666}
667
Richard Smithb9bf3122013-09-20 20:10:22 +0000668/// Check whether the initializer \p IList (that was written with explicit
669/// braces) can be used to initialize an object of type \p T.
670///
671/// This also fills in \p StructuredList with the fully-braced, desugared
672/// form of the initialization.
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000673void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000674 InitListExpr *IList, QualType &T,
Douglas Gregor4c678342009-01-28 21:54:33 +0000675 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000676 bool TopLevelObject) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000677 assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
Sebastian Redl14b0c192011-09-24 17:48:00 +0000678 if (!VerifyOnly) {
679 SyntacticToSemantic[IList] = StructuredList;
680 StructuredList->setSyntacticForm(IList);
681 }
Richard Smithb9bf3122013-09-20 20:10:22 +0000682
683 unsigned Index = 0, StructuredIndex = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000684 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
Anders Carlsson46f46592010-01-23 19:55:29 +0000685 Index, StructuredList, StructuredIndex, TopLevelObject);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000686 if (!VerifyOnly) {
Eli Friedman5c89c392012-02-23 02:25:10 +0000687 QualType ExprTy = T;
688 if (!ExprTy->isArrayType())
689 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000690 IList->setType(ExprTy);
691 StructuredList->setType(ExprTy);
692 }
Eli Friedman638e1442008-05-25 13:22:35 +0000693 if (hadError)
694 return;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000695
Eli Friedman638e1442008-05-25 13:22:35 +0000696 if (Index < IList->getNumInits()) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000697 // We have leftover initializers
Sebastian Redl14b0c192011-09-24 17:48:00 +0000698 if (VerifyOnly) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000699 if (SemaRef.getLangOpts().CPlusPlus ||
700 (SemaRef.getLangOpts().OpenCL &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000701 IList->getType()->isVectorType())) {
702 hadError = true;
703 }
704 return;
705 }
706
Eli Friedmane5408582009-05-29 20:20:05 +0000707 if (StructuredIndex == 1 &&
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000708 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
709 SIF_None) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000710 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
David Blaikie4e4d0842012-03-11 07:00:24 +0000711 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000712 DK = diag::err_excess_initializers_in_char_array_initializer;
Eli Friedmane5408582009-05-29 20:20:05 +0000713 hadError = true;
714 }
Eli Friedmanbb504d32008-05-19 20:12:18 +0000715 // Special-case
Chris Lattner08202542009-02-24 22:50:46 +0000716 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000717 << IList->getInit(Index)->getSourceRange();
Eli Friedmand8dc2102008-05-20 05:25:56 +0000718 } else if (!T->isIncompleteType()) {
Douglas Gregorb574e562009-01-30 22:26:29 +0000719 // Don't complain for incomplete types, since we'll get an error
720 // elsewhere
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000721 QualType CurrentObjectType = StructuredList->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000722 int initKind =
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000723 CurrentObjectType->isArrayType()? 0 :
724 CurrentObjectType->isVectorType()? 1 :
725 CurrentObjectType->isScalarType()? 2 :
726 CurrentObjectType->isUnionType()? 3 :
727 4;
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000728
729 unsigned DK = diag::warn_excess_initializers;
David Blaikie4e4d0842012-03-11 07:00:24 +0000730 if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmane5408582009-05-29 20:20:05 +0000731 DK = diag::err_excess_initializers;
732 hadError = true;
733 }
David Blaikie4e4d0842012-03-11 07:00:24 +0000734 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
Nate Begeman08634522009-07-07 21:53:06 +0000735 DK = diag::err_excess_initializers;
736 hadError = true;
737 }
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000738
Chris Lattner08202542009-02-24 22:50:46 +0000739 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000740 << initKind << IList->getInit(Index)->getSourceRange();
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000741 }
742 }
Eli Friedmancda25a92008-05-19 20:20:43 +0000743
Sebastian Redl14b0c192011-09-24 17:48:00 +0000744 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
745 !TopLevelObject)
Chris Lattner08202542009-02-24 22:50:46 +0000746 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
Douglas Gregora3a83512009-04-01 23:51:29 +0000747 << IList->getSourceRange()
Douglas Gregor849b2432010-03-31 17:46:05 +0000748 << FixItHint::CreateRemoval(IList->getLocStart())
749 << FixItHint::CreateRemoval(IList->getLocEnd());
Steve Naroff0cca7492008-05-01 22:18:59 +0000750}
751
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000752void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000753 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000754 QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +0000755 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +0000756 unsigned &Index,
757 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000758 unsigned &StructuredIndex,
759 bool TopLevelObject) {
Eli Friedman0c706c22011-09-19 23:17:44 +0000760 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
761 // Explicitly braced initializer for complex type can be real+imaginary
762 // parts.
763 CheckComplexType(Entity, IList, DeclType, Index,
764 StructuredList, StructuredIndex);
765 } else if (DeclType->isScalarType()) {
Anders Carlsson46f46592010-01-23 19:55:29 +0000766 CheckScalarType(Entity, IList, DeclType, Index,
767 StructuredList, StructuredIndex);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000768 } else if (DeclType->isVectorType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000769 CheckVectorType(Entity, IList, DeclType, Index,
Anders Carlsson46f46592010-01-23 19:55:29 +0000770 StructuredList, StructuredIndex);
Richard Smith20599392012-07-07 08:35:56 +0000771 } else if (DeclType->isRecordType()) {
772 assert(DeclType->isAggregateType() &&
773 "non-aggregate records should be handed in CheckSubElementType");
774 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
775 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
776 SubobjectIsDesignatorContext, Index,
777 StructuredList, StructuredIndex,
778 TopLevelObject);
779 } else if (DeclType->isArrayType()) {
780 llvm::APSInt Zero(
781 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
782 false);
783 CheckArrayType(Entity, IList, DeclType, Zero,
784 SubobjectIsDesignatorContext, Index,
785 StructuredList, StructuredIndex);
Steve Naroff61353522008-08-10 16:05:48 +0000786 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
787 // This type is invalid, issue a diagnostic.
Douglas Gregor4c678342009-01-28 21:54:33 +0000788 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000789 if (!VerifyOnly)
790 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
791 << DeclType;
Eli Friedmand8dc2102008-05-20 05:25:56 +0000792 hadError = true;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000793 } else if (DeclType->isReferenceType()) {
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000794 CheckReferenceType(Entity, IList, DeclType, Index,
795 StructuredList, StructuredIndex);
John McCallc12c5bb2010-05-15 11:32:37 +0000796 } else if (DeclType->isObjCObjectType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000797 if (!VerifyOnly)
798 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
799 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000800 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000801 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000802 if (!VerifyOnly)
803 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
804 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000805 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000806 }
807}
808
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000809void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000810 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000811 QualType ElemType,
Douglas Gregor4c678342009-01-28 21:54:33 +0000812 unsigned &Index,
813 InitListExpr *StructuredList,
814 unsigned &StructuredIndex) {
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000815 Expr *expr = IList->getInit(Index);
Richard Smith6242a452013-05-31 02:56:17 +0000816
817 if (ElemType->isReferenceType())
818 return CheckReferenceType(Entity, IList, ElemType, Index,
819 StructuredList, StructuredIndex);
820
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000821 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
Richard Smith20599392012-07-07 08:35:56 +0000822 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
Richard Smithb9bf3122013-09-20 20:10:22 +0000823 InitListExpr *InnerStructuredList
Richard Smith20599392012-07-07 08:35:56 +0000824 = getStructuredSubobjectInit(IList, Index, ElemType,
825 StructuredList, StructuredIndex,
826 SubInitList->getSourceRange());
Richard Smithb9bf3122013-09-20 20:10:22 +0000827 CheckExplicitInitList(Entity, SubInitList, ElemType,
828 InnerStructuredList);
Richard Smith20599392012-07-07 08:35:56 +0000829 ++StructuredIndex;
830 ++Index;
831 return;
832 }
833 assert(SemaRef.getLangOpts().CPlusPlus &&
834 "non-aggregate records are only possible in C++");
835 // C++ initialization is handled later.
836 }
837
Eli Friedman48a2a3a2013-08-19 22:12:56 +0000838 // FIXME: Need to handle atomic aggregate types with implicit init lists.
839 if (ElemType->isScalarType() || ElemType->isAtomicType())
John McCallfef8b342011-02-21 07:57:55 +0000840 return CheckScalarType(Entity, IList, ElemType, Index,
841 StructuredList, StructuredIndex);
Anders Carlssond28b4282009-08-27 17:18:13 +0000842
Eli Friedman48a2a3a2013-08-19 22:12:56 +0000843 assert((ElemType->isRecordType() || ElemType->isVectorType() ||
844 ElemType->isArrayType()) && "Unexpected type");
845
John McCallfef8b342011-02-21 07:57:55 +0000846 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
847 // arrayType can be incomplete if we're initializing a flexible
848 // array member. There's nothing we can do with the completed
849 // type here, though.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000850
Hans Wennborg0ff50742013-05-15 11:03:04 +0000851 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
Eli Friedman8a5d9292011-09-26 19:09:09 +0000852 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +0000853 CheckStringInit(expr, ElemType, arrayType, SemaRef);
854 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
Eli Friedman8a5d9292011-09-26 19:09:09 +0000855 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000856 ++Index;
John McCallfef8b342011-02-21 07:57:55 +0000857 return;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000858 }
John McCallfef8b342011-02-21 07:57:55 +0000859
860 // Fall through for subaggregate initialization.
861
David Blaikie4e4d0842012-03-11 07:00:24 +0000862 } else if (SemaRef.getLangOpts().CPlusPlus) {
John McCallfef8b342011-02-21 07:57:55 +0000863 // C++ [dcl.init.aggr]p12:
864 // All implicit type conversions (clause 4) are considered when
Sebastian Redl5d3d41d2011-09-24 17:47:39 +0000865 // initializing the aggregate member with an initializer from
John McCallfef8b342011-02-21 07:57:55 +0000866 // an initializer-list. If the initializer can initialize a
867 // member, the member is initialized. [...]
868
869 // FIXME: Better EqualLoc?
870 InitializationKind Kind =
871 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000872 InitializationSequence Seq(SemaRef, Entity, Kind, expr);
John McCallfef8b342011-02-21 07:57:55 +0000873
874 if (Seq) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000875 if (!VerifyOnly) {
Richard Smithb6f8d282011-12-20 04:00:21 +0000876 ExprResult Result =
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000877 Seq.Perform(SemaRef, Entity, Kind, expr);
Richard Smithb6f8d282011-12-20 04:00:21 +0000878 if (Result.isInvalid())
879 hadError = true;
John McCallfef8b342011-02-21 07:57:55 +0000880
Sebastian Redl14b0c192011-09-24 17:48:00 +0000881 UpdateStructuredListElement(StructuredList, StructuredIndex,
Richard Smithb6f8d282011-12-20 04:00:21 +0000882 Result.takeAs<Expr>());
Sebastian Redl14b0c192011-09-24 17:48:00 +0000883 }
John McCallfef8b342011-02-21 07:57:55 +0000884 ++Index;
885 return;
886 }
887
888 // Fall through for subaggregate initialization
889 } else {
890 // C99 6.7.8p13:
891 //
892 // The initializer for a structure or union object that has
893 // automatic storage duration shall be either an initializer
894 // list as described below, or a single expression that has
895 // compatible structure or union type. In the latter case, the
896 // initial value of the object, including unnamed members, is
897 // that of the expression.
John Wiegley429bb272011-04-08 18:41:53 +0000898 ExprResult ExprRes = SemaRef.Owned(expr);
John McCallfef8b342011-02-21 07:57:55 +0000899 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000900 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
901 !VerifyOnly)
Eli Friedman08f0bbc2013-09-17 04:07:04 +0000902 != Sema::Incompatible) {
John Wiegley429bb272011-04-08 18:41:53 +0000903 if (ExprRes.isInvalid())
904 hadError = true;
905 else {
906 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000907 if (ExprRes.isInvalid())
908 hadError = true;
John Wiegley429bb272011-04-08 18:41:53 +0000909 }
910 UpdateStructuredListElement(StructuredList, StructuredIndex,
911 ExprRes.takeAs<Expr>());
John McCallfef8b342011-02-21 07:57:55 +0000912 ++Index;
913 return;
914 }
John Wiegley429bb272011-04-08 18:41:53 +0000915 ExprRes.release();
John McCallfef8b342011-02-21 07:57:55 +0000916 // Fall through for subaggregate initialization
917 }
918
919 // C++ [dcl.init.aggr]p12:
920 //
921 // [...] Otherwise, if the member is itself a non-empty
922 // subaggregate, brace elision is assumed and the initializer is
923 // considered for the initialization of the first member of
924 // the subaggregate.
David Blaikie4e4d0842012-03-11 07:00:24 +0000925 if (!SemaRef.getLangOpts().OpenCL &&
Tanya Lattner61b4bc82011-07-15 23:07:01 +0000926 (ElemType->isAggregateType() || ElemType->isVectorType())) {
John McCallfef8b342011-02-21 07:57:55 +0000927 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
928 StructuredIndex);
929 ++StructuredIndex;
930 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000931 if (!VerifyOnly) {
932 // We cannot initialize this element, so let
933 // PerformCopyInitialization produce the appropriate diagnostic.
934 SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
935 SemaRef.Owned(expr),
936 /*TopLevelOfInitList=*/true);
937 }
John McCallfef8b342011-02-21 07:57:55 +0000938 hadError = true;
939 ++Index;
940 ++StructuredIndex;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000941 }
Eli Friedmanb85f7072008-05-19 19:16:24 +0000942}
943
Eli Friedman0c706c22011-09-19 23:17:44 +0000944void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
945 InitListExpr *IList, QualType DeclType,
946 unsigned &Index,
947 InitListExpr *StructuredList,
948 unsigned &StructuredIndex) {
949 assert(Index == 0 && "Index in explicit init list must be zero");
950
951 // As an extension, clang supports complex initializers, which initialize
952 // a complex number component-wise. When an explicit initializer list for
953 // a complex number contains two two initializers, this extension kicks in:
954 // it exepcts the initializer list to contain two elements convertible to
955 // the element type of the complex type. The first element initializes
956 // the real part, and the second element intitializes the imaginary part.
957
958 if (IList->getNumInits() != 2)
959 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
960 StructuredIndex);
961
962 // This is an extension in C. (The builtin _Complex type does not exist
963 // in the C++ standard.)
David Blaikie4e4d0842012-03-11 07:00:24 +0000964 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
Eli Friedman0c706c22011-09-19 23:17:44 +0000965 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
966 << IList->getSourceRange();
967
968 // Initialize the complex number.
969 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
970 InitializedEntity ElementEntity =
971 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
972
973 for (unsigned i = 0; i < 2; ++i) {
974 ElementEntity.setElementIndex(Index);
975 CheckSubElementType(ElementEntity, IList, elementType, Index,
976 StructuredList, StructuredIndex);
977 }
978}
979
980
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000981void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000982 InitListExpr *IList, QualType DeclType,
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000983 unsigned &Index,
Douglas Gregor4c678342009-01-28 21:54:33 +0000984 InitListExpr *StructuredList,
985 unsigned &StructuredIndex) {
John McCallb934c2d2010-11-11 00:46:36 +0000986 if (Index >= IList->getNumInits()) {
Richard Smith6b130222011-10-18 21:39:00 +0000987 if (!VerifyOnly)
988 SemaRef.Diag(IList->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +0000989 SemaRef.getLangOpts().CPlusPlus11 ?
Richard Smith6b130222011-10-18 21:39:00 +0000990 diag::warn_cxx98_compat_empty_scalar_initializer :
991 diag::err_empty_scalar_initializer)
992 << IList->getSourceRange();
Richard Smith80ad52f2013-01-02 11:42:31 +0000993 hadError = !SemaRef.getLangOpts().CPlusPlus11;
Douglas Gregor4c678342009-01-28 21:54:33 +0000994 ++Index;
995 ++StructuredIndex;
Eli Friedmanbb504d32008-05-19 20:12:18 +0000996 return;
Steve Naroff0cca7492008-05-01 22:18:59 +0000997 }
John McCallb934c2d2010-11-11 00:46:36 +0000998
999 Expr *expr = IList->getInit(Index);
1000 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001001 // FIXME: This is invalid, and accepting it causes overload resolution
1002 // to pick the wrong overload in some corner cases.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001003 if (!VerifyOnly)
1004 SemaRef.Diag(SubIList->getLocStart(),
Stephen Hines651f13c2014-04-23 16:59:28 -07001005 diag::ext_many_braces_around_scalar_init)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001006 << SubIList->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001007
1008 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1009 StructuredIndex);
1010 return;
1011 } else if (isa<DesignatedInitExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001012 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001013 SemaRef.Diag(expr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001014 diag::err_designator_for_scalar_init)
1015 << DeclType << expr->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001016 hadError = true;
1017 ++Index;
1018 ++StructuredIndex;
1019 return;
1020 }
1021
Sebastian Redl14b0c192011-09-24 17:48:00 +00001022 if (VerifyOnly) {
1023 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1024 hadError = true;
1025 ++Index;
1026 return;
1027 }
1028
John McCallb934c2d2010-11-11 00:46:36 +00001029 ExprResult Result =
1030 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001031 SemaRef.Owned(expr),
1032 /*TopLevelOfInitList=*/true);
John McCallb934c2d2010-11-11 00:46:36 +00001033
1034 Expr *ResultExpr = 0;
1035
1036 if (Result.isInvalid())
1037 hadError = true; // types weren't compatible.
1038 else {
1039 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001040
John McCallb934c2d2010-11-11 00:46:36 +00001041 if (ResultExpr != expr) {
1042 // The type was promoted, update initializer list.
1043 IList->setInit(Index, ResultExpr);
1044 }
1045 }
1046 if (hadError)
1047 ++StructuredIndex;
1048 else
1049 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1050 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001051}
1052
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001053void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1054 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +00001055 unsigned &Index,
1056 InitListExpr *StructuredList,
1057 unsigned &StructuredIndex) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001058 if (Index >= IList->getNumInits()) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001059 // FIXME: It would be wonderful if we could point at the actual member. In
1060 // general, it would be useful to pass location information down the stack,
1061 // so that we know the location (or decl) of the "current object" being
1062 // initialized.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001063 if (!VerifyOnly)
1064 SemaRef.Diag(IList->getLocStart(),
1065 diag::err_init_reference_member_uninitialized)
1066 << DeclType
1067 << IList->getSourceRange();
Douglas Gregor930d8b52009-01-30 22:09:00 +00001068 hadError = true;
1069 ++Index;
1070 ++StructuredIndex;
1071 return;
1072 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001073
1074 Expr *expr = IList->getInit(Index);
Richard Smith80ad52f2013-01-02 11:42:31 +00001075 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001076 if (!VerifyOnly)
1077 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1078 << DeclType << IList->getSourceRange();
1079 hadError = true;
1080 ++Index;
1081 ++StructuredIndex;
1082 return;
1083 }
1084
1085 if (VerifyOnly) {
1086 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1087 hadError = true;
1088 ++Index;
1089 return;
1090 }
1091
1092 ExprResult Result =
1093 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1094 SemaRef.Owned(expr),
1095 /*TopLevelOfInitList=*/true);
1096
1097 if (Result.isInvalid())
1098 hadError = true;
1099
1100 expr = Result.takeAs<Expr>();
1101 IList->setInit(Index, expr);
1102
1103 if (hadError)
1104 ++StructuredIndex;
1105 else
1106 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1107 ++Index;
Douglas Gregor930d8b52009-01-30 22:09:00 +00001108}
1109
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001110void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +00001111 InitListExpr *IList, QualType DeclType,
Douglas Gregor4c678342009-01-28 21:54:33 +00001112 unsigned &Index,
1113 InitListExpr *StructuredList,
1114 unsigned &StructuredIndex) {
John McCall20e047a2010-10-30 00:11:39 +00001115 const VectorType *VT = DeclType->getAs<VectorType>();
1116 unsigned maxElements = VT->getNumElements();
1117 unsigned numEltsInit = 0;
1118 QualType elementType = VT->getElementType();
Anders Carlsson46f46592010-01-23 19:55:29 +00001119
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001120 if (Index >= IList->getNumInits()) {
1121 // Make sure the element type can be value-initialized.
1122 if (VerifyOnly)
1123 CheckValueInitializable(
1124 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity));
1125 return;
1126 }
1127
David Blaikie4e4d0842012-03-11 07:00:24 +00001128 if (!SemaRef.getLangOpts().OpenCL) {
John McCall20e047a2010-10-30 00:11:39 +00001129 // If the initializing element is a vector, try to copy-initialize
1130 // instead of breaking it apart (which is doomed to failure anyway).
1131 Expr *Init = IList->getInit(Index);
1132 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001133 if (VerifyOnly) {
1134 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(Init)))
1135 hadError = true;
1136 ++Index;
1137 return;
1138 }
1139
John McCall20e047a2010-10-30 00:11:39 +00001140 ExprResult Result =
1141 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001142 SemaRef.Owned(Init),
1143 /*TopLevelOfInitList=*/true);
John McCall20e047a2010-10-30 00:11:39 +00001144
1145 Expr *ResultExpr = 0;
1146 if (Result.isInvalid())
1147 hadError = true; // types weren't compatible.
1148 else {
1149 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001150
John McCall20e047a2010-10-30 00:11:39 +00001151 if (ResultExpr != Init) {
1152 // The type was promoted, update initializer list.
1153 IList->setInit(Index, ResultExpr);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001154 }
1155 }
John McCall20e047a2010-10-30 00:11:39 +00001156 if (hadError)
1157 ++StructuredIndex;
1158 else
Sebastian Redl14b0c192011-09-24 17:48:00 +00001159 UpdateStructuredListElement(StructuredList, StructuredIndex,
1160 ResultExpr);
John McCall20e047a2010-10-30 00:11:39 +00001161 ++Index;
1162 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001163 }
Mike Stump1eb44332009-09-09 15:08:12 +00001164
John McCall20e047a2010-10-30 00:11:39 +00001165 InitializedEntity ElementEntity =
1166 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001167
John McCall20e047a2010-10-30 00:11:39 +00001168 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1169 // Don't attempt to go past the end of the init list
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001170 if (Index >= IList->getNumInits()) {
1171 if (VerifyOnly)
1172 CheckValueInitializable(ElementEntity);
John McCall20e047a2010-10-30 00:11:39 +00001173 break;
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001174 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001175
John McCall20e047a2010-10-30 00:11:39 +00001176 ElementEntity.setElementIndex(Index);
1177 CheckSubElementType(ElementEntity, IList, elementType, Index,
1178 StructuredList, StructuredIndex);
1179 }
1180 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001181 }
John McCall20e047a2010-10-30 00:11:39 +00001182
1183 InitializedEntity ElementEntity =
1184 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001185
John McCall20e047a2010-10-30 00:11:39 +00001186 // OpenCL initializers allows vectors to be constructed from vectors.
1187 for (unsigned i = 0; i < maxElements; ++i) {
1188 // Don't attempt to go past the end of the init list
1189 if (Index >= IList->getNumInits())
1190 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001191
John McCall20e047a2010-10-30 00:11:39 +00001192 ElementEntity.setElementIndex(Index);
1193
1194 QualType IType = IList->getInit(Index)->getType();
1195 if (!IType->isVectorType()) {
1196 CheckSubElementType(ElementEntity, IList, elementType, Index,
1197 StructuredList, StructuredIndex);
1198 ++numEltsInit;
1199 } else {
1200 QualType VecType;
1201 const VectorType *IVT = IType->getAs<VectorType>();
1202 unsigned numIElts = IVT->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001203
John McCall20e047a2010-10-30 00:11:39 +00001204 if (IType->isExtVectorType())
1205 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1206 else
1207 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
Bob Wilsone86d78c2010-11-10 21:56:12 +00001208 IVT->getVectorKind());
John McCall20e047a2010-10-30 00:11:39 +00001209 CheckSubElementType(ElementEntity, IList, VecType, Index,
1210 StructuredList, StructuredIndex);
1211 numEltsInit += numIElts;
1212 }
1213 }
1214
1215 // OpenCL requires all elements to be initialized.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001216 if (numEltsInit != maxElements) {
1217 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001218 SemaRef.Diag(IList->getLocStart(),
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001219 diag::err_vector_incorrect_num_initializers)
1220 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1221 hadError = true;
1222 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001223}
1224
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001225void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +00001226 InitListExpr *IList, QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001227 llvm::APSInt elementIndex,
Mike Stump1eb44332009-09-09 15:08:12 +00001228 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001229 unsigned &Index,
1230 InitListExpr *StructuredList,
1231 unsigned &StructuredIndex) {
John McCallce6c9b72011-02-21 07:22:22 +00001232 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1233
Steve Naroff0cca7492008-05-01 22:18:59 +00001234 // Check for the special-case of initializing an array with a string.
1235 if (Index < IList->getNumInits()) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001236 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1237 SIF_None) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001238 // We place the string literal directly into the resulting
1239 // initializer list. This is the only place where the structure
1240 // of the structured initializer list doesn't match exactly,
1241 // because doing so would involve allocating one character
1242 // constant for each string.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001243 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001244 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1245 UpdateStructuredListElement(StructuredList, StructuredIndex,
1246 IList->getInit(Index));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001247 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1248 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001249 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001250 return;
1251 }
1252 }
John McCallce6c9b72011-02-21 07:22:22 +00001253 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
Eli Friedman638e1442008-05-25 13:22:35 +00001254 // Check for VLAs; in standard C it would be possible to check this
1255 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1256 // them in all sorts of strange places).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001257 if (!VerifyOnly)
1258 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1259 diag::err_variable_object_no_init)
1260 << VAT->getSizeExpr()->getSourceRange();
Eli Friedman638e1442008-05-25 13:22:35 +00001261 hadError = true;
Douglas Gregor4c678342009-01-28 21:54:33 +00001262 ++Index;
1263 ++StructuredIndex;
Eli Friedman638e1442008-05-25 13:22:35 +00001264 return;
1265 }
1266
Douglas Gregor05c13a32009-01-22 00:58:24 +00001267 // We might know the maximum number of elements in advance.
Douglas Gregor4c678342009-01-28 21:54:33 +00001268 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1269 elementIndex.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001270 bool maxElementsKnown = false;
John McCallce6c9b72011-02-21 07:22:22 +00001271 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00001272 maxElements = CAT->getSize();
Jay Foad9f71a8f2010-12-07 08:25:34 +00001273 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001274 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001275 maxElementsKnown = true;
1276 }
1277
John McCallce6c9b72011-02-21 07:22:22 +00001278 QualType elementType = arrayType->getElementType();
Douglas Gregor05c13a32009-01-22 00:58:24 +00001279 while (Index < IList->getNumInits()) {
1280 Expr *Init = IList->getInit(Index);
1281 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001282 // If we're not the subobject that matches up with the '{' for
1283 // the designator, we shouldn't be handling the
1284 // designator. Return immediately.
1285 if (!SubobjectIsDesignatorContext)
1286 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001287
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001288 // Handle this designated initializer. elementIndex will be
1289 // updated to be the next array element we'll initialize.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001290 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001291 DeclType, 0, &elementIndex, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001292 StructuredList, StructuredIndex, true,
1293 false)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001294 hadError = true;
1295 continue;
1296 }
1297
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001298 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001299 maxElements = maxElements.extend(elementIndex.getBitWidth());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001300 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001301 elementIndex = elementIndex.extend(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001302 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001303
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001304 // If the array is of incomplete type, keep track of the number of
1305 // elements in the initializer.
1306 if (!maxElementsKnown && elementIndex > maxElements)
1307 maxElements = elementIndex;
1308
Douglas Gregor05c13a32009-01-22 00:58:24 +00001309 continue;
1310 }
1311
1312 // If we know the maximum number of elements, and we've already
1313 // hit it, stop consuming elements in the initializer list.
1314 if (maxElementsKnown && elementIndex == maxElements)
Steve Naroff0cca7492008-05-01 22:18:59 +00001315 break;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001316
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001317 InitializedEntity ElementEntity =
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001318 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001319 Entity);
1320 // Check this element.
1321 CheckSubElementType(ElementEntity, IList, elementType, Index,
1322 StructuredList, StructuredIndex);
Douglas Gregor05c13a32009-01-22 00:58:24 +00001323 ++elementIndex;
1324
1325 // If the array is of incomplete type, keep track of the number of
1326 // elements in the initializer.
1327 if (!maxElementsKnown && elementIndex > maxElements)
1328 maxElements = elementIndex;
Steve Naroff0cca7492008-05-01 22:18:59 +00001329 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001330 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +00001331 // If this is an incomplete array type, the actual type needs to
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001332 // be calculated here.
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001333 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001334 if (maxElements == Zero) {
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001335 // Sizing an array implicitly to zero is not allowed by ISO C,
1336 // but is supported by GNU.
Chris Lattner08202542009-02-24 22:50:46 +00001337 SemaRef.Diag(IList->getLocStart(),
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001338 diag::ext_typecheck_zero_array_size);
Steve Naroff0cca7492008-05-01 22:18:59 +00001339 }
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001340
Mike Stump1eb44332009-09-09 15:08:12 +00001341 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001342 ArrayType::Normal, 0);
Steve Naroff0cca7492008-05-01 22:18:59 +00001343 }
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001344 if (!hadError && VerifyOnly) {
1345 // Check if there are any members of the array that get value-initialized.
1346 // If so, check if doing that is possible.
1347 // FIXME: This needs to detect holes left by designated initializers too.
1348 if (maxElementsKnown && elementIndex < maxElements)
1349 CheckValueInitializable(InitializedEntity::InitializeElement(
1350 SemaRef.Context, 0, Entity));
1351 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001352}
1353
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001354bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1355 Expr *InitExpr,
1356 FieldDecl *Field,
1357 bool TopLevelObject) {
1358 // Handle GNU flexible array initializers.
1359 unsigned FlexArrayDiag;
1360 if (isa<InitListExpr>(InitExpr) &&
1361 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1362 // Empty flexible array init always allowed as an extension
1363 FlexArrayDiag = diag::ext_flexible_array_init;
David Blaikie4e4d0842012-03-11 07:00:24 +00001364 } else if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001365 // Disallow flexible array init in C++; it is not required for gcc
1366 // compatibility, and it needs work to IRGen correctly in general.
1367 FlexArrayDiag = diag::err_flexible_array_init;
1368 } else if (!TopLevelObject) {
1369 // Disallow flexible array init on non-top-level object
1370 FlexArrayDiag = diag::err_flexible_array_init;
1371 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1372 // Disallow flexible array init on anything which is not a variable.
1373 FlexArrayDiag = diag::err_flexible_array_init;
1374 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1375 // Disallow flexible array init on local variables.
1376 FlexArrayDiag = diag::err_flexible_array_init;
1377 } else {
1378 // Allow other cases.
1379 FlexArrayDiag = diag::ext_flexible_array_init;
1380 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001381
1382 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001383 SemaRef.Diag(InitExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001384 FlexArrayDiag)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001385 << InitExpr->getLocStart();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001386 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1387 << Field;
1388 }
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001389
1390 return FlexArrayDiag != diag::ext_flexible_array_init;
1391}
1392
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001393void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +00001394 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +00001395 QualType DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001396 RecordDecl::field_iterator Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001397 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001398 unsigned &Index,
1399 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001400 unsigned &StructuredIndex,
1401 bool TopLevelObject) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001402 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001403
Eli Friedmanb85f7072008-05-19 19:16:24 +00001404 // If the record is invalid, some of it's members are invalid. To avoid
1405 // confusion, we forgo checking the intializer for the entire record.
1406 if (structDecl->isInvalidDecl()) {
Richard Smith72ab2772012-09-28 21:23:50 +00001407 // Assume it was supposed to consume a single initializer.
1408 ++Index;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001409 hadError = true;
1410 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001411 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001412
1413 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001414 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Richard Smithc3bf52c2013-04-20 22:23:05 +00001415
1416 // If there's a default initializer, use it.
1417 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1418 if (VerifyOnly)
1419 return;
1420 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1421 Field != FieldEnd; ++Field) {
1422 if (Field->hasInClassInitializer()) {
1423 StructuredList->setInitializedFieldInUnion(*Field);
1424 // FIXME: Actually build a CXXDefaultInitExpr?
1425 return;
1426 }
1427 }
1428 }
1429
1430 // Value-initialize the first named member of the union.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001431 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1432 Field != FieldEnd; ++Field) {
1433 if (Field->getDeclName()) {
1434 if (VerifyOnly)
1435 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001436 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001437 else
David Blaikie581deb32012-06-06 20:45:41 +00001438 StructuredList->setInitializedFieldInUnion(*Field);
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001439 break;
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001440 }
1441 }
1442 return;
1443 }
1444
Douglas Gregor05c13a32009-01-22 00:58:24 +00001445 // If structDecl is a forward declaration, this loop won't do
1446 // anything except look at designated initializers; That's okay,
1447 // because an error should get printed out elsewhere. It might be
1448 // worthwhile to skip over the rest of the initializer, though.
Ted Kremenek6217b802009-07-29 21:53:49 +00001449 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001450 RecordDecl::field_iterator FieldEnd = RD->field_end();
Douglas Gregordfb5e592009-02-12 19:00:39 +00001451 bool InitializedSomething = false;
John McCall80639de2010-03-11 19:32:38 +00001452 bool CheckForMissingFields = true;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001453 while (Index < IList->getNumInits()) {
1454 Expr *Init = IList->getInit(Index);
1455
1456 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001457 // If we're not the subobject that matches up with the '{' for
1458 // the designator, we shouldn't be handling the
1459 // designator. Return immediately.
1460 if (!SubobjectIsDesignatorContext)
1461 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001462
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001463 // Handle this designated initializer. Field will be updated to
1464 // the next field that we'll be initializing.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001465 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Douglas Gregor4c678342009-01-28 21:54:33 +00001466 DeclType, &Field, 0, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001467 StructuredList, StructuredIndex,
1468 true, TopLevelObject))
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001469 hadError = true;
1470
Douglas Gregordfb5e592009-02-12 19:00:39 +00001471 InitializedSomething = true;
John McCall80639de2010-03-11 19:32:38 +00001472
1473 // Disable check for missing fields when designators are used.
1474 // This matches gcc behaviour.
1475 CheckForMissingFields = false;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001476 continue;
1477 }
1478
1479 if (Field == FieldEnd) {
1480 // We've run out of fields. We're done.
1481 break;
1482 }
1483
Douglas Gregordfb5e592009-02-12 19:00:39 +00001484 // We've already initialized a member of a union. We're done.
1485 if (InitializedSomething && DeclType->isUnionType())
1486 break;
1487
Douglas Gregor44b43212008-12-11 16:49:14 +00001488 // If we've hit the flexible array member at the end, we're done.
1489 if (Field->getType()->isIncompleteArrayType())
1490 break;
1491
Douglas Gregor0bb76892009-01-29 16:53:55 +00001492 if (Field->isUnnamedBitfield()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001493 // Don't initialize unnamed bitfields, e.g. "int : 20;"
Douglas Gregor05c13a32009-01-22 00:58:24 +00001494 ++Field;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001495 continue;
Steve Naroff0cca7492008-05-01 22:18:59 +00001496 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001497
Douglas Gregor54001c12011-06-29 21:51:31 +00001498 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001499 bool InvalidUse;
1500 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001501 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001502 else
David Blaikie581deb32012-06-06 20:45:41 +00001503 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001504 IList->getInit(Index)->getLocStart());
1505 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001506 ++Index;
1507 ++Field;
1508 hadError = true;
1509 continue;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001510 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001511
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001512 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001513 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001514 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1515 StructuredList, StructuredIndex);
Douglas Gregordfb5e592009-02-12 19:00:39 +00001516 InitializedSomething = true;
Douglas Gregor0bb76892009-01-29 16:53:55 +00001517
Sebastian Redl14b0c192011-09-24 17:48:00 +00001518 if (DeclType->isUnionType() && !VerifyOnly) {
Douglas Gregor0bb76892009-01-29 16:53:55 +00001519 // Initialize the first field within the union.
David Blaikie581deb32012-06-06 20:45:41 +00001520 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001521 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00001522
1523 ++Field;
Steve Naroff0cca7492008-05-01 22:18:59 +00001524 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001525
John McCall80639de2010-03-11 19:32:38 +00001526 // Emit warnings for missing struct field initializers.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001527 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1528 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1529 !DeclType->isUnionType()) {
John McCall80639de2010-03-11 19:32:38 +00001530 // It is possible we have one or more unnamed bitfields remaining.
1531 // Find first (if any) named field and emit warning.
1532 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1533 it != end; ++it) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001534 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
John McCall80639de2010-03-11 19:32:38 +00001535 SemaRef.Diag(IList->getSourceRange().getEnd(),
Stephen Hines651f13c2014-04-23 16:59:28 -07001536 diag::warn_missing_field_initializers) << *it;
John McCall80639de2010-03-11 19:32:38 +00001537 break;
1538 }
1539 }
1540 }
1541
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001542 // Check that any remaining fields can be value-initialized.
1543 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1544 !Field->getType()->isIncompleteArrayType()) {
1545 // FIXME: Should check for holes left by designated initializers too.
1546 for (; Field != FieldEnd && !hadError; ++Field) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001547 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001548 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001549 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001550 }
1551 }
1552
Mike Stump1eb44332009-09-09 15:08:12 +00001553 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
Douglas Gregora6457962009-03-20 00:32:56 +00001554 Index >= IList->getNumInits())
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001555 return;
1556
David Blaikie581deb32012-06-06 20:45:41 +00001557 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001558 TopLevelObject)) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001559 hadError = true;
Douglas Gregora6457962009-03-20 00:32:56 +00001560 ++Index;
1561 return;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001562 }
1563
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001564 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001565 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001566
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001567 if (isa<InitListExpr>(IList->getInit(Index)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001568 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001569 StructuredList, StructuredIndex);
1570 else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001571 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson987dc6a2010-01-23 20:47:59 +00001572 StructuredList, StructuredIndex);
Steve Naroff0cca7492008-05-01 22:18:59 +00001573}
Steve Naroff0cca7492008-05-01 22:18:59 +00001574
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001575/// \brief Expand a field designator that refers to a member of an
1576/// anonymous struct or union into a series of field designators that
1577/// refers to the field within the appropriate subobject.
1578///
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001579static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
Mike Stump1eb44332009-09-09 15:08:12 +00001580 DesignatedInitExpr *DIE,
1581 unsigned DesigIdx,
Francois Picheta0e27f02010-12-22 03:46:10 +00001582 IndirectFieldDecl *IndirectField) {
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001583 typedef DesignatedInitExpr::Designator Designator;
1584
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001585 // Build the replacement designators.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001586 SmallVector<Designator, 4> Replacements;
Francois Picheta0e27f02010-12-22 03:46:10 +00001587 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1588 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1589 if (PI + 1 == PE)
Mike Stump1eb44332009-09-09 15:08:12 +00001590 Replacements.push_back(Designator((IdentifierInfo *)0,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001591 DIE->getDesignator(DesigIdx)->getDotLoc(),
1592 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1593 else
1594 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1595 SourceLocation()));
Francois Picheta0e27f02010-12-22 03:46:10 +00001596 assert(isa<FieldDecl>(*PI));
1597 Replacements.back().setField(cast<FieldDecl>(*PI));
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001598 }
1599
1600 // Expand the current designator into the set of replacement
1601 // designators, so we have a full subobject path down to where the
1602 // member of the anonymous struct/union is actually stored.
Douglas Gregor319d57f2010-01-06 23:17:19 +00001603 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001604 &Replacements[0] + Replacements.size());
Francois Picheta0e27f02010-12-22 03:46:10 +00001605}
Mike Stump1eb44332009-09-09 15:08:12 +00001606
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001607/// \brief Given an implicit anonymous field, search the IndirectField that
Francois Picheta0e27f02010-12-22 03:46:10 +00001608/// corresponds to FieldName.
1609static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField,
1610 IdentifierInfo *FieldName) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001611 if (!FieldName)
1612 return 0;
1613
Francois Picheta0e27f02010-12-22 03:46:10 +00001614 assert(AnonField->isAnonymousStructOrUnion());
1615 Decl *NextDecl = AnonField->getNextDeclInContext();
Aaron Ballman3e78b192012-02-09 22:16:56 +00001616 while (IndirectFieldDecl *IF =
1617 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001618 if (FieldName == IF->getAnonField()->getIdentifier())
Francois Picheta0e27f02010-12-22 03:46:10 +00001619 return IF;
1620 NextDecl = NextDecl->getNextDeclInContext();
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001621 }
Francois Picheta0e27f02010-12-22 03:46:10 +00001622 return 0;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001623}
1624
Sebastian Redl14b0c192011-09-24 17:48:00 +00001625static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1626 DesignatedInitExpr *DIE) {
1627 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1628 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1629 for (unsigned I = 0; I < NumIndexExprs; ++I)
1630 IndexExprs[I] = DIE->getSubExpr(I + 1);
1631 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001632 DIE->size(), IndexExprs,
1633 DIE->getEqualOrColonLoc(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001634 DIE->usesGNUSyntax(), DIE->getInit());
1635}
1636
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001637namespace {
1638
1639// Callback to only accept typo corrections that are for field members of
1640// the given struct or union.
1641class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1642 public:
1643 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1644 : Record(RD) {}
1645
Stephen Hines651f13c2014-04-23 16:59:28 -07001646 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001647 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1648 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1649 }
1650
1651 private:
1652 RecordDecl *Record;
1653};
1654
1655}
1656
Douglas Gregor05c13a32009-01-22 00:58:24 +00001657/// @brief Check the well-formedness of a C99 designated initializer.
1658///
1659/// Determines whether the designated initializer @p DIE, which
1660/// resides at the given @p Index within the initializer list @p
1661/// IList, is well-formed for a current object of type @p DeclType
1662/// (C99 6.7.8). The actual subobject that this designator refers to
Mike Stump1eb44332009-09-09 15:08:12 +00001663/// within the current subobject is returned in either
Douglas Gregor4c678342009-01-28 21:54:33 +00001664/// @p NextField or @p NextElementIndex (whichever is appropriate).
Douglas Gregor05c13a32009-01-22 00:58:24 +00001665///
1666/// @param IList The initializer list in which this designated
1667/// initializer occurs.
1668///
Douglas Gregor71199712009-04-15 04:56:10 +00001669/// @param DIE The designated initializer expression.
1670///
1671/// @param DesigIdx The index of the current designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001672///
Dmitri Gribenko70517ca2012-08-23 17:58:28 +00001673/// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
Douglas Gregor05c13a32009-01-22 00:58:24 +00001674/// into which the designation in @p DIE should refer.
1675///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001676/// @param NextField If non-NULL and the first designator in @p DIE is
1677/// a field, this will be set to the field declaration corresponding
1678/// to the field named by the designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001679///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001680/// @param NextElementIndex If non-NULL and the first designator in @p
1681/// DIE is an array designator or GNU array-range designator, this
1682/// will be set to the last index initialized by this designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001683///
1684/// @param Index Index into @p IList where the designated initializer
1685/// @p DIE occurs.
1686///
Douglas Gregor4c678342009-01-28 21:54:33 +00001687/// @param StructuredList The initializer list expression that
1688/// describes all of the subobject initializers in the order they'll
1689/// actually be initialized.
1690///
Douglas Gregor05c13a32009-01-22 00:58:24 +00001691/// @returns true if there was an error, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00001692bool
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001693InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001694 InitListExpr *IList,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001695 DesignatedInitExpr *DIE,
1696 unsigned DesigIdx,
1697 QualType &CurrentObjectType,
1698 RecordDecl::field_iterator *NextField,
1699 llvm::APSInt *NextElementIndex,
1700 unsigned &Index,
1701 InitListExpr *StructuredList,
1702 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001703 bool FinishSubobjectInit,
1704 bool TopLevelObject) {
Douglas Gregor71199712009-04-15 04:56:10 +00001705 if (DesigIdx == DIE->size()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001706 // Check the actual initialization for the designated object type.
1707 bool prevHadError = hadError;
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001708
1709 // Temporarily remove the designator expression from the
1710 // initializer list that the child calls see, so that we don't try
1711 // to re-process the designator.
1712 unsigned OldIndex = Index;
1713 IList->setInit(OldIndex, DIE->getInit());
1714
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001715 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001716 StructuredList, StructuredIndex);
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001717
1718 // Restore the designated initializer expression in the syntactic
1719 // form of the initializer list.
1720 if (IList->getInit(OldIndex) != DIE->getInit())
1721 DIE->setInit(IList->getInit(OldIndex));
1722 IList->setInit(OldIndex, DIE);
1723
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001724 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001725 }
1726
Douglas Gregor71199712009-04-15 04:56:10 +00001727 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001728 bool IsFirstDesignator = (DesigIdx == 0);
1729 if (!VerifyOnly) {
1730 assert((IsFirstDesignator || StructuredList) &&
1731 "Need a non-designated initializer list to start from");
1732
1733 // Determine the structural initializer list that corresponds to the
1734 // current subobject.
Benjamin Kramera7894162012-02-23 14:48:40 +00001735 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001736 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1737 StructuredList, StructuredIndex,
Erik Verbruggen65d78312012-12-25 14:51:39 +00001738 SourceRange(D->getLocStart(),
1739 DIE->getLocEnd()));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001740 assert(StructuredList && "Expected a structured initializer list");
1741 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001742
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001743 if (D->isFieldDesignator()) {
1744 // C99 6.7.8p7:
1745 //
1746 // If a designator has the form
1747 //
1748 // . identifier
1749 //
1750 // then the current object (defined below) shall have
1751 // structure or union type and the identifier shall be the
Mike Stump1eb44332009-09-09 15:08:12 +00001752 // name of a member of that type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001753 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001754 if (!RT) {
1755 SourceLocation Loc = D->getDotLoc();
1756 if (Loc.isInvalid())
1757 Loc = D->getFieldLoc();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001758 if (!VerifyOnly)
1759 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
David Blaikie4e4d0842012-03-11 07:00:24 +00001760 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001761 ++Index;
1762 return true;
1763 }
1764
Douglas Gregor4c678342009-01-28 21:54:33 +00001765 // Note: we perform a linear search of the fields here, despite
1766 // the fact that we have a faster lookup method, because we always
1767 // need to compute the field's index.
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001768 FieldDecl *KnownField = D->getField();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001769 IdentifierInfo *FieldName = D->getFieldName();
Douglas Gregor4c678342009-01-28 21:54:33 +00001770 unsigned FieldIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001771 RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001772 Field = RT->getDecl()->field_begin(),
1773 FieldEnd = RT->getDecl()->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +00001774 for (; Field != FieldEnd; ++Field) {
1775 if (Field->isUnnamedBitfield())
1776 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001777
Francois Picheta0e27f02010-12-22 03:46:10 +00001778 // If we find a field representing an anonymous field, look in the
1779 // IndirectFieldDecl that follow for the designated initializer.
1780 if (!KnownField && Field->isAnonymousStructOrUnion()) {
1781 if (IndirectFieldDecl *IF =
David Blaikie581deb32012-06-06 20:45:41 +00001782 FindIndirectFieldDesignator(*Field, FieldName)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001783 // In verify mode, don't modify the original.
1784 if (VerifyOnly)
1785 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
Francois Picheta0e27f02010-12-22 03:46:10 +00001786 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF);
1787 D = DIE->getDesignator(DesigIdx);
1788 break;
1789 }
1790 }
David Blaikie581deb32012-06-06 20:45:41 +00001791 if (KnownField && KnownField == *Field)
Douglas Gregor022d13d2010-10-08 20:44:28 +00001792 break;
1793 if (FieldName && FieldName == Field->getIdentifier())
Douglas Gregor4c678342009-01-28 21:54:33 +00001794 break;
1795
1796 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001797 }
1798
Douglas Gregor4c678342009-01-28 21:54:33 +00001799 if (Field == FieldEnd) {
Benjamin Kramera41ee492011-09-25 02:41:26 +00001800 if (VerifyOnly) {
1801 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001802 return true; // No typo correction when just trying this out.
Benjamin Kramera41ee492011-09-25 02:41:26 +00001803 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001804
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001805 // There was no normal field in the struct with the designated
1806 // name. Perform another lookup for this name, which may find
1807 // something that we can't designate (e.g., a member function),
1808 // may find nothing, or may find a member of an anonymous
Mike Stump1eb44332009-09-09 15:08:12 +00001809 // struct/union.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001810 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001811 FieldDecl *ReplacementField = 0;
David Blaikie3bc93e32012-12-19 00:45:41 +00001812 if (Lookup.empty()) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001813 // Name lookup didn't find anything. Determine whether this
1814 // was a typo for another field name.
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001815 FieldInitializerValidatorCCC Validator(RT->getDecl());
Richard Smith2d670972013-08-17 00:46:16 +00001816 if (TypoCorrection Corrected = SemaRef.CorrectTypo(
1817 DeclarationNameInfo(FieldName, D->getFieldLoc()),
1818 Sema::LookupMemberName, /*Scope=*/ 0, /*SS=*/ 0, Validator,
1819 RT->getDecl())) {
1820 SemaRef.diagnoseTypo(
1821 Corrected,
1822 SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
1823 << FieldName << CurrentObjectType);
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001824 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>();
Benjamin Kramera41ee492011-09-25 02:41:26 +00001825 hadError = true;
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001826 } else {
1827 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1828 << FieldName << CurrentObjectType;
1829 ++Index;
1830 return true;
1831 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001832 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001833
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001834 if (!ReplacementField) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001835 // Name lookup found something, but it wasn't a field.
Chris Lattner08202542009-02-24 22:50:46 +00001836 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
Douglas Gregor4c678342009-01-28 21:54:33 +00001837 << FieldName;
David Blaikie3bc93e32012-12-19 00:45:41 +00001838 SemaRef.Diag(Lookup.front()->getLocation(),
Douglas Gregor4c678342009-01-28 21:54:33 +00001839 diag::note_field_designator_found);
Eli Friedmanba79fc22009-04-16 17:49:48 +00001840 ++Index;
1841 return true;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001842 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001843
Francois Picheta0e27f02010-12-22 03:46:10 +00001844 if (!KnownField) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001845 // The replacement field comes from typo correction; find it
1846 // in the list of fields.
1847 FieldIndex = 0;
1848 Field = RT->getDecl()->field_begin();
1849 for (; Field != FieldEnd; ++Field) {
1850 if (Field->isUnnamedBitfield())
1851 continue;
1852
David Blaikie581deb32012-06-06 20:45:41 +00001853 if (ReplacementField == *Field ||
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001854 Field->getIdentifier() == ReplacementField->getIdentifier())
1855 break;
1856
1857 ++FieldIndex;
1858 }
1859 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001860 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001861
1862 // All of the fields of a union are located at the same place in
1863 // the initializer list.
Douglas Gregor0bb76892009-01-29 16:53:55 +00001864 if (RT->getDecl()->isUnion()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001865 FieldIndex = 0;
Matthew Curtis4e499522013-10-03 12:14:24 +00001866 if (!VerifyOnly) {
1867 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
1868 if (CurrentField && CurrentField != *Field) {
1869 assert(StructuredList->getNumInits() == 1
1870 && "A union should never have more than one initializer!");
1871
1872 // we're about to throw away an initializer, emit warning
1873 SemaRef.Diag(D->getFieldLoc(),
1874 diag::warn_initializer_overrides)
1875 << D->getSourceRange();
1876 Expr *ExistingInit = StructuredList->getInit(0);
1877 SemaRef.Diag(ExistingInit->getLocStart(),
1878 diag::note_previous_initializer)
1879 << /*FIXME:has side effects=*/0
1880 << ExistingInit->getSourceRange();
1881
1882 // remove existing initializer
1883 StructuredList->resizeInits(SemaRef.Context, 0);
1884 StructuredList->setInitializedFieldInUnion(0);
1885 }
1886
David Blaikie581deb32012-06-06 20:45:41 +00001887 StructuredList->setInitializedFieldInUnion(*Field);
Matthew Curtis4e499522013-10-03 12:14:24 +00001888 }
Douglas Gregor0bb76892009-01-29 16:53:55 +00001889 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001890
Douglas Gregor54001c12011-06-29 21:51:31 +00001891 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001892 bool InvalidUse;
1893 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001894 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001895 else
David Blaikie581deb32012-06-06 20:45:41 +00001896 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001897 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001898 ++Index;
1899 return true;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001900 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001901
Sebastian Redl14b0c192011-09-24 17:48:00 +00001902 if (!VerifyOnly) {
1903 // Update the designator with the field declaration.
David Blaikie581deb32012-06-06 20:45:41 +00001904 D->setField(*Field);
Mike Stump1eb44332009-09-09 15:08:12 +00001905
Sebastian Redl14b0c192011-09-24 17:48:00 +00001906 // Make sure that our non-designated initializer list has space
1907 // for a subobject corresponding to this field.
1908 if (FieldIndex >= StructuredList->getNumInits())
1909 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1910 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001911
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001912 // This designator names a flexible array member.
1913 if (Field->getType()->isIncompleteArrayType()) {
1914 bool Invalid = false;
Douglas Gregor71199712009-04-15 04:56:10 +00001915 if ((DesigIdx + 1) != DIE->size()) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001916 // We can't designate an object within the flexible array
1917 // member (because GCC doesn't allow it).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001918 if (!VerifyOnly) {
1919 DesignatedInitExpr::Designator *NextD
1920 = DIE->getDesignator(DesigIdx + 1);
Erik Verbruggen65d78312012-12-25 14:51:39 +00001921 SemaRef.Diag(NextD->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001922 diag::err_designator_into_flexible_array_member)
Erik Verbruggen65d78312012-12-25 14:51:39 +00001923 << SourceRange(NextD->getLocStart(),
1924 DIE->getLocEnd());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001925 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001926 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001927 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001928 Invalid = true;
1929 }
1930
Chris Lattner9046c222010-10-10 17:49:49 +00001931 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
1932 !isa<StringLiteral>(DIE->getInit())) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001933 // The initializer is not an initializer list.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001934 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001935 SemaRef.Diag(DIE->getInit()->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001936 diag::err_flexible_array_init_needs_braces)
1937 << DIE->getInit()->getSourceRange();
1938 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001939 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001940 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001941 Invalid = true;
1942 }
1943
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001944 // Check GNU flexible array initializer.
David Blaikie581deb32012-06-06 20:45:41 +00001945 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001946 TopLevelObject))
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001947 Invalid = true;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001948
1949 if (Invalid) {
1950 ++Index;
1951 return true;
1952 }
1953
1954 // Initialize the array.
1955 bool prevHadError = hadError;
1956 unsigned newStructuredIndex = FieldIndex;
1957 unsigned OldIndex = Index;
1958 IList->setInit(Index, DIE->getInit());
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001959
1960 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001961 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001962 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001963 StructuredList, newStructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001964
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001965 IList->setInit(OldIndex, DIE);
1966 if (hadError && !prevHadError) {
1967 ++Field;
1968 ++FieldIndex;
1969 if (NextField)
1970 *NextField = Field;
1971 StructuredIndex = FieldIndex;
1972 return true;
1973 }
1974 } else {
1975 // Recurse to check later designated subobjects.
David Blaikie262bc182012-04-30 02:36:29 +00001976 QualType FieldType = Field->getType();
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001977 unsigned newStructuredIndex = FieldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001978
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001979 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001980 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001981 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
1982 FieldType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001983 StructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001984 true, false))
1985 return true;
1986 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001987
1988 // Find the position of the next field to be initialized in this
1989 // subobject.
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001990 ++Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001991 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001992
1993 // If this the first designator, our caller will continue checking
1994 // the rest of this struct/class/union subobject.
1995 if (IsFirstDesignator) {
1996 if (NextField)
1997 *NextField = Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001998 StructuredIndex = FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001999 return false;
2000 }
2001
Douglas Gregor34e79462009-01-28 23:36:17 +00002002 if (!FinishSubobjectInit)
2003 return false;
2004
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00002005 // We've already initialized something in the union; we're done.
2006 if (RT->getDecl()->isUnion())
2007 return hadError;
2008
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002009 // Check the remaining fields within this class/struct/union subobject.
2010 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002011
Anders Carlsson8ff9e862010-01-23 23:23:01 +00002012 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002013 StructuredList, FieldIndex);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002014 return hadError && !prevHadError;
2015 }
2016
2017 // C99 6.7.8p6:
2018 //
2019 // If a designator has the form
2020 //
2021 // [ constant-expression ]
2022 //
2023 // then the current object (defined below) shall have array
2024 // type and the expression shall be an integer constant
2025 // expression. If the array is of unknown size, any
2026 // nonnegative value is valid.
2027 //
2028 // Additionally, cope with the GNU extension that permits
2029 // designators of the form
2030 //
2031 // [ constant-expression ... constant-expression ]
Chris Lattner08202542009-02-24 22:50:46 +00002032 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002033 if (!AT) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002034 if (!VerifyOnly)
2035 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2036 << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002037 ++Index;
2038 return true;
2039 }
2040
2041 Expr *IndexExpr = 0;
Douglas Gregor34e79462009-01-28 23:36:17 +00002042 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2043 if (D->isArrayDesignator()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002044 IndexExpr = DIE->getArrayIndex(*D);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002045 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor34e79462009-01-28 23:36:17 +00002046 DesignatedEndIndex = DesignatedStartIndex;
2047 } else {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002048 assert(D->isArrayRangeDesignator() && "Need array-range designator");
Douglas Gregor34e79462009-01-28 23:36:17 +00002049
Mike Stump1eb44332009-09-09 15:08:12 +00002050 DesignatedStartIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002051 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
Mike Stump1eb44332009-09-09 15:08:12 +00002052 DesignatedEndIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002053 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002054 IndexExpr = DIE->getArrayRangeEnd(*D);
Douglas Gregor34e79462009-01-28 23:36:17 +00002055
Chris Lattnere0fd8322011-02-19 22:28:58 +00002056 // Codegen can't handle evaluating array range designators that have side
2057 // effects, because we replicate the AST value for each initialized element.
2058 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2059 // elements with something that has a side effect, so codegen can emit an
2060 // "error unsupported" error instead of miscompiling the app.
2061 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
Sebastian Redl14b0c192011-09-24 17:48:00 +00002062 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
Douglas Gregora9c87802009-01-29 19:42:23 +00002063 FullyStructuredList->sawArrayRangeDesignator();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002064 }
2065
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002066 if (isa<ConstantArrayType>(AT)) {
2067 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
Jay Foad9f71a8f2010-12-07 08:25:34 +00002068 DesignatedStartIndex
2069 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002070 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
Jay Foad9f71a8f2010-12-07 08:25:34 +00002071 DesignatedEndIndex
2072 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002073 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2074 if (DesignatedEndIndex >= MaxElements) {
Eli Friedmana4e20e12011-09-26 18:53:43 +00002075 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00002076 SemaRef.Diag(IndexExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00002077 diag::err_array_designator_too_large)
2078 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2079 << IndexExpr->getSourceRange();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002080 ++Index;
2081 return true;
2082 }
Douglas Gregor34e79462009-01-28 23:36:17 +00002083 } else {
2084 // Make sure the bit-widths and signedness match.
2085 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002086 DesignatedEndIndex
2087 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
Chris Lattner3bf68932009-04-25 21:59:05 +00002088 else if (DesignatedStartIndex.getBitWidth() <
2089 DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002090 DesignatedStartIndex
2091 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002092 DesignatedStartIndex.setIsUnsigned(true);
2093 DesignatedEndIndex.setIsUnsigned(true);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002094 }
Mike Stump1eb44332009-09-09 15:08:12 +00002095
Eli Friedman188ddb12013-06-11 21:48:11 +00002096 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2097 // We're modifying a string literal init; we have to decompose the string
2098 // so we can modify the individual characters.
2099 ASTContext &Context = SemaRef.Context;
2100 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2101
2102 // Compute the character type
2103 QualType CharTy = AT->getElementType();
2104
2105 // Compute the type of the integer literals.
2106 QualType PromotedCharTy = CharTy;
2107 if (CharTy->isPromotableIntegerType())
2108 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2109 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2110
2111 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2112 // Get the length of the string.
2113 uint64_t StrLen = SL->getLength();
2114 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2115 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2116 StructuredList->resizeInits(Context, StrLen);
2117
2118 // Build a literal for each character in the string, and put them into
2119 // the init list.
2120 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2121 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2122 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002123 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002124 if (CharTy != PromotedCharTy)
2125 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2126 Init, 0, VK_RValue);
2127 StructuredList->updateInit(Context, i, Init);
2128 }
2129 } else {
2130 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2131 std::string Str;
2132 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2133
2134 // Get the length of the string.
2135 uint64_t StrLen = Str.size();
2136 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2137 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2138 StructuredList->resizeInits(Context, StrLen);
2139
2140 // Build a literal for each character in the string, and put them into
2141 // the init list.
2142 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2143 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2144 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002145 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002146 if (CharTy != PromotedCharTy)
2147 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2148 Init, 0, VK_RValue);
2149 StructuredList->updateInit(Context, i, Init);
2150 }
2151 }
2152 }
2153
Douglas Gregor4c678342009-01-28 21:54:33 +00002154 // Make sure that our non-designated initializer list has space
2155 // for a subobject corresponding to this array element.
Sebastian Redl14b0c192011-09-24 17:48:00 +00002156 if (!VerifyOnly &&
2157 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
Mike Stump1eb44332009-09-09 15:08:12 +00002158 StructuredList->resizeInits(SemaRef.Context,
Douglas Gregor34e79462009-01-28 23:36:17 +00002159 DesignatedEndIndex.getZExtValue() + 1);
Douglas Gregor4c678342009-01-28 21:54:33 +00002160
Douglas Gregor34e79462009-01-28 23:36:17 +00002161 // Repeatedly perform subobject initializations in the range
2162 // [DesignatedStartIndex, DesignatedEndIndex].
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002163
Douglas Gregor34e79462009-01-28 23:36:17 +00002164 // Move to the next designator
2165 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2166 unsigned OldIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002167
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002168 InitializedEntity ElementEntity =
Anders Carlsson8ff9e862010-01-23 23:23:01 +00002169 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002170
Douglas Gregor34e79462009-01-28 23:36:17 +00002171 while (DesignatedStartIndex <= DesignatedEndIndex) {
2172 // Recurse to check later designated subobjects.
2173 QualType ElementType = AT->getElementType();
2174 Index = OldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002175
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002176 ElementEntity.setElementIndex(ElementIndex);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002177 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2178 ElementType, 0, 0, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002179 StructuredList, ElementIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00002180 (DesignatedStartIndex == DesignatedEndIndex),
2181 false))
Douglas Gregor34e79462009-01-28 23:36:17 +00002182 return true;
2183
2184 // Move to the next index in the array that we'll be initializing.
2185 ++DesignatedStartIndex;
2186 ElementIndex = DesignatedStartIndex.getZExtValue();
2187 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002188
2189 // If this the first designator, our caller will continue checking
2190 // the rest of this array subobject.
2191 if (IsFirstDesignator) {
2192 if (NextElementIndex)
Douglas Gregor34e79462009-01-28 23:36:17 +00002193 *NextElementIndex = DesignatedStartIndex;
Douglas Gregor4c678342009-01-28 21:54:33 +00002194 StructuredIndex = ElementIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002195 return false;
2196 }
Mike Stump1eb44332009-09-09 15:08:12 +00002197
Douglas Gregor34e79462009-01-28 23:36:17 +00002198 if (!FinishSubobjectInit)
2199 return false;
2200
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002201 // Check the remaining elements within this array subobject.
Douglas Gregor05c13a32009-01-22 00:58:24 +00002202 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002203 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
Anders Carlsson784f6992010-01-23 20:13:41 +00002204 /*SubobjectIsDesignatorContext=*/false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002205 StructuredList, ElementIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002206 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002207}
2208
Douglas Gregor4c678342009-01-28 21:54:33 +00002209// Get the structured initializer list for a subobject of type
2210// @p CurrentObjectType.
2211InitListExpr *
2212InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2213 QualType CurrentObjectType,
2214 InitListExpr *StructuredList,
2215 unsigned StructuredIndex,
2216 SourceRange InitRange) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002217 if (VerifyOnly)
2218 return 0; // No structured list in verification-only mode.
Douglas Gregor4c678342009-01-28 21:54:33 +00002219 Expr *ExistingInit = 0;
2220 if (!StructuredList)
Benjamin Kramera7894162012-02-23 14:48:40 +00002221 ExistingInit = SyntacticToSemantic.lookup(IList);
Douglas Gregor4c678342009-01-28 21:54:33 +00002222 else if (StructuredIndex < StructuredList->getNumInits())
2223 ExistingInit = StructuredList->getInit(StructuredIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002224
Douglas Gregor4c678342009-01-28 21:54:33 +00002225 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2226 return Result;
2227
2228 if (ExistingInit) {
2229 // We are creating an initializer list that initializes the
2230 // subobjects of the current object, but there was already an
2231 // initialization that completely initialized the current
2232 // subobject, e.g., by a compound literal:
Mike Stump1eb44332009-09-09 15:08:12 +00002233 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002234 // struct X { int a, b; };
2235 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
Mike Stump1eb44332009-09-09 15:08:12 +00002236 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002237 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2238 // designated initializer re-initializes the whole
2239 // subobject [0], overwriting previous initializers.
Mike Stump1eb44332009-09-09 15:08:12 +00002240 SemaRef.Diag(InitRange.getBegin(),
Douglas Gregored8a93d2009-03-01 17:12:46 +00002241 diag::warn_subobject_initializer_overrides)
Douglas Gregor4c678342009-01-28 21:54:33 +00002242 << InitRange;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002243 SemaRef.Diag(ExistingInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002244 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002245 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002246 << ExistingInit->getSourceRange();
2247 }
2248
Mike Stump1eb44332009-09-09 15:08:12 +00002249 InitListExpr *Result
Ted Kremenek709210f2010-04-13 23:39:13 +00002250 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00002251 InitRange.getBegin(), None,
Ted Kremenekba7bc552010-02-19 01:50:18 +00002252 InitRange.getEnd());
Douglas Gregored8a93d2009-03-01 17:12:46 +00002253
Eli Friedman5c89c392012-02-23 02:25:10 +00002254 QualType ResultType = CurrentObjectType;
2255 if (!ResultType->isArrayType())
2256 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2257 Result->setType(ResultType);
Douglas Gregor4c678342009-01-28 21:54:33 +00002258
Douglas Gregorfa219202009-03-20 23:58:33 +00002259 // Pre-allocate storage for the structured initializer list.
2260 unsigned NumElements = 0;
Douglas Gregor08457732009-03-21 18:13:52 +00002261 unsigned NumInits = 0;
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002262 bool GotNumInits = false;
2263 if (!StructuredList) {
Douglas Gregor08457732009-03-21 18:13:52 +00002264 NumInits = IList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002265 GotNumInits = true;
2266 } else if (Index < IList->getNumInits()) {
2267 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
Douglas Gregor08457732009-03-21 18:13:52 +00002268 NumInits = SubList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002269 GotNumInits = true;
2270 }
Douglas Gregor08457732009-03-21 18:13:52 +00002271 }
2272
Mike Stump1eb44332009-09-09 15:08:12 +00002273 if (const ArrayType *AType
Douglas Gregorfa219202009-03-20 23:58:33 +00002274 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2275 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2276 NumElements = CAType->getSize().getZExtValue();
2277 // Simple heuristic so that we don't allocate a very large
2278 // initializer with many empty entries at the end.
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002279 if (GotNumInits && NumElements > NumInits)
Douglas Gregorfa219202009-03-20 23:58:33 +00002280 NumElements = 0;
2281 }
John McCall183700f2009-09-21 23:43:11 +00002282 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
Douglas Gregorfa219202009-03-20 23:58:33 +00002283 NumElements = VType->getNumElements();
Ted Kremenek6217b802009-07-29 21:53:49 +00002284 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
Douglas Gregorfa219202009-03-20 23:58:33 +00002285 RecordDecl *RDecl = RType->getDecl();
2286 if (RDecl->isUnion())
2287 NumElements = 1;
2288 else
Stephen Hines651f13c2014-04-23 16:59:28 -07002289 NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
Douglas Gregorfa219202009-03-20 23:58:33 +00002290 }
2291
Ted Kremenek709210f2010-04-13 23:39:13 +00002292 Result->reserveInits(SemaRef.Context, NumElements);
Douglas Gregorfa219202009-03-20 23:58:33 +00002293
Douglas Gregor4c678342009-01-28 21:54:33 +00002294 // Link this new initializer list into the structured initializer
2295 // lists.
2296 if (StructuredList)
Ted Kremenek709210f2010-04-13 23:39:13 +00002297 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
Douglas Gregor4c678342009-01-28 21:54:33 +00002298 else {
2299 Result->setSyntacticForm(IList);
2300 SyntacticToSemantic[IList] = Result;
2301 }
2302
2303 return Result;
2304}
2305
2306/// Update the initializer at index @p StructuredIndex within the
2307/// structured initializer list to the value @p expr.
2308void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2309 unsigned &StructuredIndex,
2310 Expr *expr) {
2311 // No structured initializer list to update
2312 if (!StructuredList)
2313 return;
2314
Ted Kremenek709210f2010-04-13 23:39:13 +00002315 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2316 StructuredIndex, expr)) {
Douglas Gregor4c678342009-01-28 21:54:33 +00002317 // This initializer overwrites a previous initializer. Warn.
Daniel Dunbar96a00142012-03-09 18:35:03 +00002318 SemaRef.Diag(expr->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002319 diag::warn_initializer_overrides)
2320 << expr->getSourceRange();
Daniel Dunbar96a00142012-03-09 18:35:03 +00002321 SemaRef.Diag(PrevInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002322 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002323 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002324 << PrevInit->getSourceRange();
2325 }
Mike Stump1eb44332009-09-09 15:08:12 +00002326
Douglas Gregor4c678342009-01-28 21:54:33 +00002327 ++StructuredIndex;
2328}
2329
Douglas Gregor05c13a32009-01-22 00:58:24 +00002330/// Check that the given Index expression is a valid array designator
Richard Smith282e7e62012-02-04 09:53:13 +00002331/// value. This is essentially just a wrapper around
Chris Lattner3bf68932009-04-25 21:59:05 +00002332/// VerifyIntegerConstantExpression that also checks for negative values
Douglas Gregor05c13a32009-01-22 00:58:24 +00002333/// and produces a reasonable diagnostic if there is a
Richard Smith282e7e62012-02-04 09:53:13 +00002334/// failure. Returns the index expression, possibly with an implicit cast
2335/// added, on success. If everything went okay, Value will receive the
2336/// value of the constant expression.
2337static ExprResult
Chris Lattner3bf68932009-04-25 21:59:05 +00002338CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00002339 SourceLocation Loc = Index->getLocStart();
Douglas Gregor05c13a32009-01-22 00:58:24 +00002340
2341 // Make sure this is an integer constant expression.
Richard Smith282e7e62012-02-04 09:53:13 +00002342 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2343 if (Result.isInvalid())
2344 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002345
Chris Lattner3bf68932009-04-25 21:59:05 +00002346 if (Value.isSigned() && Value.isNegative())
2347 return S.Diag(Loc, diag::err_array_designator_negative)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002348 << Value.toString(10) << Index->getSourceRange();
2349
Douglas Gregor53d3d8e2009-01-23 21:04:18 +00002350 Value.setIsUnsigned(true);
Richard Smith282e7e62012-02-04 09:53:13 +00002351 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002352}
2353
John McCall60d7b3a2010-08-24 06:29:42 +00002354ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
Nick Lewycky7663f392010-11-20 01:29:55 +00002355 SourceLocation Loc,
2356 bool GNUSyntax,
2357 ExprResult Init) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00002358 typedef DesignatedInitExpr::Designator ASTDesignator;
2359
2360 bool Invalid = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002361 SmallVector<ASTDesignator, 32> Designators;
2362 SmallVector<Expr *, 32> InitExpressions;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002363
2364 // Build designators and check array designator expressions.
2365 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2366 const Designator &D = Desig.getDesignator(Idx);
2367 switch (D.getKind()) {
2368 case Designator::FieldDesignator:
Mike Stump1eb44332009-09-09 15:08:12 +00002369 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002370 D.getFieldLoc()));
2371 break;
2372
2373 case Designator::ArrayDesignator: {
2374 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2375 llvm::APSInt IndexValue;
Richard Smith282e7e62012-02-04 09:53:13 +00002376 if (!Index->isTypeDependent() && !Index->isValueDependent())
2377 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take();
2378 if (!Index)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002379 Invalid = true;
2380 else {
2381 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002382 D.getLBracketLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002383 D.getRBracketLoc()));
2384 InitExpressions.push_back(Index);
2385 }
2386 break;
2387 }
2388
2389 case Designator::ArrayRangeDesignator: {
2390 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2391 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2392 llvm::APSInt StartValue;
2393 llvm::APSInt EndValue;
Douglas Gregor9ea62762009-05-21 23:17:49 +00002394 bool StartDependent = StartIndex->isTypeDependent() ||
2395 StartIndex->isValueDependent();
2396 bool EndDependent = EndIndex->isTypeDependent() ||
2397 EndIndex->isValueDependent();
Richard Smith282e7e62012-02-04 09:53:13 +00002398 if (!StartDependent)
2399 StartIndex =
2400 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take();
2401 if (!EndDependent)
2402 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take();
2403
2404 if (!StartIndex || !EndIndex)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002405 Invalid = true;
Douglas Gregord6f584f2009-01-23 22:22:29 +00002406 else {
2407 // Make sure we're comparing values with the same bit width.
Douglas Gregor9ea62762009-05-21 23:17:49 +00002408 if (StartDependent || EndDependent) {
2409 // Nothing to compute.
2410 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002411 EndValue = EndValue.extend(StartValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002412 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002413 StartValue = StartValue.extend(EndValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002414
Douglas Gregorc4bb7bf2009-05-21 23:30:39 +00002415 if (!StartDependent && !EndDependent && EndValue < StartValue) {
Douglas Gregord6f584f2009-01-23 22:22:29 +00002416 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
Mike Stump1eb44332009-09-09 15:08:12 +00002417 << StartValue.toString(10) << EndValue.toString(10)
Douglas Gregord6f584f2009-01-23 22:22:29 +00002418 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2419 Invalid = true;
2420 } else {
2421 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002422 D.getLBracketLoc(),
Douglas Gregord6f584f2009-01-23 22:22:29 +00002423 D.getEllipsisLoc(),
2424 D.getRBracketLoc()));
2425 InitExpressions.push_back(StartIndex);
2426 InitExpressions.push_back(EndIndex);
2427 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00002428 }
2429 break;
2430 }
2431 }
2432 }
2433
2434 if (Invalid || Init.isInvalid())
2435 return ExprError();
2436
2437 // Clear out the expressions within the designation.
2438 Desig.ClearExprs(*this);
2439
2440 DesignatedInitExpr *DIE
Jay Foadbeaaccd2009-05-21 09:52:38 +00002441 = DesignatedInitExpr::Create(Context,
2442 Designators.data(), Designators.size(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00002443 InitExpressions, Loc, GNUSyntax,
2444 Init.takeAs<Expr>());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002445
David Blaikie4e4d0842012-03-11 07:00:24 +00002446 if (!getLangOpts().C99)
Douglas Gregor2d75bbd2011-01-16 16:13:16 +00002447 Diag(DIE->getLocStart(), diag::ext_designated_init)
2448 << DIE->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002449
Douglas Gregor05c13a32009-01-22 00:58:24 +00002450 return Owned(DIE);
2451}
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002452
Douglas Gregor20093b42009-12-09 23:02:17 +00002453//===----------------------------------------------------------------------===//
2454// Initialization entity
2455//===----------------------------------------------------------------------===//
2456
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002457InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002458 const InitializedEntity &Parent)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002459 : Parent(&Parent), Index(Index)
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002460{
Anders Carlssond3d824d2010-01-23 04:34:47 +00002461 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2462 Kind = EK_ArrayElement;
Douglas Gregord6542d82009-12-22 15:35:07 +00002463 Type = AT->getElementType();
Eli Friedman0c706c22011-09-19 23:17:44 +00002464 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
Anders Carlssond3d824d2010-01-23 04:34:47 +00002465 Kind = EK_VectorElement;
Eli Friedman0c706c22011-09-19 23:17:44 +00002466 Type = VT->getElementType();
2467 } else {
2468 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2469 assert(CT && "Unexpected type");
2470 Kind = EK_ComplexElement;
2471 Type = CT->getElementType();
Anders Carlssond3d824d2010-01-23 04:34:47 +00002472 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002473}
2474
Benjamin Kramer4c7736e2013-07-24 15:28:33 +00002475InitializedEntity
2476InitializedEntity::InitializeBase(ASTContext &Context,
2477 const CXXBaseSpecifier *Base,
2478 bool IsInheritedVirtualBase) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002479 InitializedEntity Result;
2480 Result.Kind = EK_Base;
Richard Smitha4bb99c2013-06-12 21:51:50 +00002481 Result.Parent = 0;
Anders Carlsson711f34a2010-04-21 19:52:01 +00002482 Result.Base = reinterpret_cast<uintptr_t>(Base);
2483 if (IsInheritedVirtualBase)
2484 Result.Base |= 0x01;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002485
Douglas Gregord6542d82009-12-22 15:35:07 +00002486 Result.Type = Base->getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00002487 return Result;
2488}
2489
Douglas Gregor99a2e602009-12-16 01:38:02 +00002490DeclarationName InitializedEntity::getName() const {
2491 switch (getKind()) {
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002492 case EK_Parameter:
2493 case EK_Parameter_CF_Audited: {
John McCallf85e1932011-06-15 23:02:42 +00002494 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2495 return (D ? D->getDeclName() : DeclarationName());
2496 }
Douglas Gregora188ff22009-12-22 16:09:06 +00002497
2498 case EK_Variable:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002499 case EK_Member:
2500 return VariableOrMember->getDeclName();
2501
Douglas Gregor47736542012-02-15 16:57:26 +00002502 case EK_LambdaCapture:
Bill Wendling2434dcf2013-12-05 05:25:04 +00002503 return DeclarationName(Capture.VarID);
Douglas Gregor47736542012-02-15 16:57:26 +00002504
Douglas Gregor99a2e602009-12-16 01:38:02 +00002505 case EK_Result:
2506 case EK_Exception:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002507 case EK_New:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002508 case EK_Temporary:
2509 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002510 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002511 case EK_ArrayElement:
2512 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002513 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002514 case EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00002515 case EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002516 case EK_RelatedResult:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002517 return DeclarationName();
2518 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002519
David Blaikie7530c032012-01-17 06:56:22 +00002520 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor99a2e602009-12-16 01:38:02 +00002521}
2522
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002523DeclaratorDecl *InitializedEntity::getDecl() const {
2524 switch (getKind()) {
2525 case EK_Variable:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002526 case EK_Member:
2527 return VariableOrMember;
2528
John McCallf85e1932011-06-15 23:02:42 +00002529 case EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002530 case EK_Parameter_CF_Audited:
John McCallf85e1932011-06-15 23:02:42 +00002531 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2532
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002533 case EK_Result:
2534 case EK_Exception:
2535 case EK_New:
2536 case EK_Temporary:
2537 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002538 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002539 case EK_ArrayElement:
2540 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002541 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002542 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002543 case EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00002544 case EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002545 case EK_RelatedResult:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002546 return 0;
2547 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002548
David Blaikie7530c032012-01-17 06:56:22 +00002549 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002550}
2551
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002552bool InitializedEntity::allowsNRVO() const {
2553 switch (getKind()) {
2554 case EK_Result:
2555 case EK_Exception:
2556 return LocAndNRVO.NRVO;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002557
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002558 case EK_Variable:
2559 case EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002560 case EK_Parameter_CF_Audited:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002561 case EK_Member:
2562 case EK_New:
2563 case EK_Temporary:
Jordan Rose2624b812013-05-06 16:48:12 +00002564 case EK_CompoundLiteralInit:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002565 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002566 case EK_Delegating:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002567 case EK_ArrayElement:
2568 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002569 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002570 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002571 case EK_LambdaCapture:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002572 case EK_RelatedResult:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002573 break;
2574 }
2575
2576 return false;
2577}
2578
Richard Smith211c8dd2013-06-05 00:46:14 +00002579unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
Richard Smitha4bb99c2013-06-12 21:51:50 +00002580 assert(getParent() != this);
Richard Smith211c8dd2013-06-05 00:46:14 +00002581 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2582 for (unsigned I = 0; I != Depth; ++I)
2583 OS << "`-";
2584
2585 switch (getKind()) {
2586 case EK_Variable: OS << "Variable"; break;
2587 case EK_Parameter: OS << "Parameter"; break;
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002588 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2589 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00002590 case EK_Result: OS << "Result"; break;
2591 case EK_Exception: OS << "Exception"; break;
2592 case EK_Member: OS << "Member"; break;
2593 case EK_New: OS << "New"; break;
2594 case EK_Temporary: OS << "Temporary"; break;
2595 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002596 case EK_RelatedResult: OS << "RelatedResult"; break;
Richard Smith211c8dd2013-06-05 00:46:14 +00002597 case EK_Base: OS << "Base"; break;
2598 case EK_Delegating: OS << "Delegating"; break;
2599 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2600 case EK_VectorElement: OS << "VectorElement " << Index; break;
2601 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2602 case EK_BlockElement: OS << "Block"; break;
2603 case EK_LambdaCapture:
2604 OS << "LambdaCapture ";
Bill Wendling2434dcf2013-12-05 05:25:04 +00002605 OS << DeclarationName(Capture.VarID);
Richard Smith211c8dd2013-06-05 00:46:14 +00002606 break;
2607 }
2608
2609 if (Decl *D = getDecl()) {
2610 OS << " ";
2611 cast<NamedDecl>(D)->printQualifiedName(OS);
2612 }
2613
2614 OS << " '" << getType().getAsString() << "'\n";
2615
2616 return Depth + 1;
2617}
2618
2619void InitializedEntity::dump() const {
2620 dumpImpl(llvm::errs());
2621}
2622
Douglas Gregor20093b42009-12-09 23:02:17 +00002623//===----------------------------------------------------------------------===//
2624// Initialization sequence
2625//===----------------------------------------------------------------------===//
2626
2627void InitializationSequence::Step::Destroy() {
2628 switch (Kind) {
2629 case SK_ResolveAddressOfOverloadedFunction:
2630 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002631 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002632 case SK_CastDerivedToBaseLValue:
2633 case SK_BindReference:
2634 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00002635 case SK_ExtraneousCopyToTemporary:
Douglas Gregor20093b42009-12-09 23:02:17 +00002636 case SK_UserConversion:
2637 case SK_QualificationConversionRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002638 case SK_QualificationConversionXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002639 case SK_QualificationConversionLValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00002640 case SK_LValueToRValue:
Douglas Gregord87b61f2009-12-10 17:56:55 +00002641 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002642 case SK_ListConstructorCall:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002643 case SK_UnwrapInitList:
2644 case SK_RewrapInitList:
Douglas Gregor51c56d62009-12-14 20:49:26 +00002645 case SK_ConstructorInitialization:
Douglas Gregor71d17402009-12-15 00:01:57 +00002646 case SK_ZeroInitialization:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002647 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002648 case SK_StringInit:
Douglas Gregor569c3162010-08-07 11:51:51 +00002649 case SK_ObjCObjectConversion:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002650 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00002651 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00002652 case SK_PassByIndirectCopyRestore:
2653 case SK_PassByIndirectRestore:
2654 case SK_ProduceObjCObject:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002655 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00002656 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00002657 case SK_OCLZeroEvent:
Douglas Gregor20093b42009-12-09 23:02:17 +00002658 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002659
Douglas Gregor20093b42009-12-09 23:02:17 +00002660 case SK_ConversionSequence:
Richard Smith13b228d2013-09-21 21:19:19 +00002661 case SK_ConversionSequenceNoNarrowing:
Douglas Gregor20093b42009-12-09 23:02:17 +00002662 delete ICS;
2663 }
2664}
2665
Douglas Gregorb70cf442010-03-26 20:14:36 +00002666bool InitializationSequence::isDirectReferenceBinding() const {
Sebastian Redl3b802322011-07-14 19:07:55 +00002667 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
Douglas Gregorb70cf442010-03-26 20:14:36 +00002668}
2669
2670bool InitializationSequence::isAmbiguous() const {
Sebastian Redld695d6b2011-06-05 13:59:05 +00002671 if (!Failed())
Douglas Gregorb70cf442010-03-26 20:14:36 +00002672 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002673
Douglas Gregorb70cf442010-03-26 20:14:36 +00002674 switch (getFailureKind()) {
2675 case FK_TooManyInitsForReference:
2676 case FK_ArrayNeedsInitList:
2677 case FK_ArrayNeedsInitListOrStringLiteral:
Hans Wennborg0ff50742013-05-15 11:03:04 +00002678 case FK_ArrayNeedsInitListOrWideStringLiteral:
2679 case FK_NarrowStringIntoWideCharArray:
2680 case FK_WideStringIntoCharArray:
2681 case FK_IncompatWideStringIntoWideChar:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002682 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2683 case FK_NonConstLValueReferenceBindingToTemporary:
2684 case FK_NonConstLValueReferenceBindingToUnrelated:
2685 case FK_RValueReferenceBindingToLValue:
2686 case FK_ReferenceInitDropsQualifiers:
2687 case FK_ReferenceInitFailed:
2688 case FK_ConversionFailed:
John Wiegley429bb272011-04-08 18:41:53 +00002689 case FK_ConversionFromPropertyFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002690 case FK_TooManyInitsForScalar:
2691 case FK_ReferenceBindingToInitList:
2692 case FK_InitListBadDestinationType:
2693 case FK_DefaultInitOfConst:
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002694 case FK_Incomplete:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002695 case FK_ArrayTypeMismatch:
2696 case FK_NonConstantArrayInit:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002697 case FK_ListInitializationFailed:
John McCall73076432012-01-05 00:13:19 +00002698 case FK_VariableLengthArrayHasInitializer:
John McCall5acb0c92011-10-17 18:40:02 +00002699 case FK_PlaceholderType:
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002700 case FK_ExplicitConstructor:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002701 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002702
Douglas Gregorb70cf442010-03-26 20:14:36 +00002703 case FK_ReferenceInitOverloadFailed:
2704 case FK_UserConversionOverloadFailed:
2705 case FK_ConstructorOverloadFailed:
Sebastian Redlcf15cef2011-12-22 18:58:38 +00002706 case FK_ListConstructorOverloadFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002707 return FailedOverloadResult == OR_Ambiguous;
2708 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002709
David Blaikie7530c032012-01-17 06:56:22 +00002710 llvm_unreachable("Invalid EntityKind!");
Douglas Gregorb70cf442010-03-26 20:14:36 +00002711}
2712
Douglas Gregord6e44a32010-04-16 22:09:46 +00002713bool InitializationSequence::isConstructorInitialization() const {
2714 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2715}
2716
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002717void
2718InitializationSequence
2719::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2720 DeclAccessPair Found,
2721 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002722 Step S;
2723 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2724 S.Type = Function->getType();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002725 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002726 S.Function.Function = Function;
John McCall6bb80172010-03-30 21:47:33 +00002727 S.Function.FoundDecl = Found;
Douglas Gregor20093b42009-12-09 23:02:17 +00002728 Steps.push_back(S);
2729}
2730
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002731void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00002732 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002733 Step S;
John McCall5baba9d2010-08-25 10:28:54 +00002734 switch (VK) {
2735 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2736 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2737 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002738 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002739 S.Type = BaseType;
2740 Steps.push_back(S);
2741}
2742
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002743void InitializationSequence::AddReferenceBindingStep(QualType T,
Douglas Gregor20093b42009-12-09 23:02:17 +00002744 bool BindingTemporary) {
2745 Step S;
2746 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2747 S.Type = T;
2748 Steps.push_back(S);
2749}
2750
Douglas Gregor523d46a2010-04-18 07:40:54 +00002751void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2752 Step S;
2753 S.Kind = SK_ExtraneousCopyToTemporary;
2754 S.Type = T;
2755 Steps.push_back(S);
2756}
2757
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002758void
2759InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2760 DeclAccessPair FoundDecl,
2761 QualType T,
2762 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002763 Step S;
2764 S.Kind = SK_UserConversion;
Eli Friedman03981012009-12-11 02:42:07 +00002765 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002766 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002767 S.Function.Function = Function;
2768 S.Function.FoundDecl = FoundDecl;
Douglas Gregor20093b42009-12-09 23:02:17 +00002769 Steps.push_back(S);
2770}
2771
2772void InitializationSequence::AddQualificationConversionStep(QualType Ty,
John McCall5baba9d2010-08-25 10:28:54 +00002773 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002774 Step S;
John McCall38a4ffe2010-08-26 16:36:35 +00002775 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
John McCall5baba9d2010-08-25 10:28:54 +00002776 switch (VK) {
2777 case VK_RValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002778 S.Kind = SK_QualificationConversionRValue;
2779 break;
John McCall5baba9d2010-08-25 10:28:54 +00002780 case VK_XValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002781 S.Kind = SK_QualificationConversionXValue;
2782 break;
John McCall5baba9d2010-08-25 10:28:54 +00002783 case VK_LValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002784 S.Kind = SK_QualificationConversionLValue;
2785 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002786 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002787 S.Type = Ty;
2788 Steps.push_back(S);
2789}
2790
Jordan Rose1fd1e282013-04-11 00:58:58 +00002791void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
2792 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
2793
2794 Step S;
2795 S.Kind = SK_LValueToRValue;
2796 S.Type = Ty;
2797 Steps.push_back(S);
2798}
2799
Douglas Gregor20093b42009-12-09 23:02:17 +00002800void InitializationSequence::AddConversionSequenceStep(
Richard Smith13b228d2013-09-21 21:19:19 +00002801 const ImplicitConversionSequence &ICS, QualType T,
2802 bool TopLevelOfInitList) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002803 Step S;
Richard Smith13b228d2013-09-21 21:19:19 +00002804 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
2805 : SK_ConversionSequence;
Douglas Gregor20093b42009-12-09 23:02:17 +00002806 S.Type = T;
2807 S.ICS = new ImplicitConversionSequence(ICS);
2808 Steps.push_back(S);
2809}
2810
Douglas Gregord87b61f2009-12-10 17:56:55 +00002811void InitializationSequence::AddListInitializationStep(QualType T) {
2812 Step S;
2813 S.Kind = SK_ListInitialization;
2814 S.Type = T;
2815 Steps.push_back(S);
2816}
2817
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002818void
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002819InitializationSequence
2820::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2821 AccessSpecifier Access,
2822 QualType T,
Sebastian Redl10f04a62011-12-22 14:44:04 +00002823 bool HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002824 bool FromInitList, bool AsInitList) {
Douglas Gregor51c56d62009-12-14 20:49:26 +00002825 Step S;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002826 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall
2827 : SK_ConstructorInitialization;
Douglas Gregor51c56d62009-12-14 20:49:26 +00002828 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002829 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002830 S.Function.Function = Constructor;
2831 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
Douglas Gregor51c56d62009-12-14 20:49:26 +00002832 Steps.push_back(S);
2833}
2834
Douglas Gregor71d17402009-12-15 00:01:57 +00002835void InitializationSequence::AddZeroInitializationStep(QualType T) {
2836 Step S;
2837 S.Kind = SK_ZeroInitialization;
2838 S.Type = T;
2839 Steps.push_back(S);
2840}
2841
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002842void InitializationSequence::AddCAssignmentStep(QualType T) {
2843 Step S;
2844 S.Kind = SK_CAssignment;
2845 S.Type = T;
2846 Steps.push_back(S);
2847}
2848
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002849void InitializationSequence::AddStringInitStep(QualType T) {
2850 Step S;
2851 S.Kind = SK_StringInit;
2852 S.Type = T;
2853 Steps.push_back(S);
2854}
2855
Douglas Gregor569c3162010-08-07 11:51:51 +00002856void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2857 Step S;
2858 S.Kind = SK_ObjCObjectConversion;
2859 S.Type = T;
2860 Steps.push_back(S);
2861}
2862
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002863void InitializationSequence::AddArrayInitStep(QualType T) {
2864 Step S;
2865 S.Kind = SK_ArrayInit;
2866 S.Type = T;
2867 Steps.push_back(S);
2868}
2869
Richard Smith0f163e92012-02-15 22:38:09 +00002870void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2871 Step S;
2872 S.Kind = SK_ParenthesizedArrayInit;
2873 S.Type = T;
2874 Steps.push_back(S);
2875}
2876
John McCallf85e1932011-06-15 23:02:42 +00002877void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2878 bool shouldCopy) {
2879 Step s;
2880 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2881 : SK_PassByIndirectRestore);
2882 s.Type = type;
2883 Steps.push_back(s);
2884}
2885
2886void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2887 Step S;
2888 S.Kind = SK_ProduceObjCObject;
2889 S.Type = T;
2890 Steps.push_back(S);
2891}
2892
Sebastian Redl2b916b82012-01-17 22:49:42 +00002893void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2894 Step S;
2895 S.Kind = SK_StdInitializerList;
2896 S.Type = T;
2897 Steps.push_back(S);
2898}
2899
Guy Benyei21f18c42013-02-07 10:55:47 +00002900void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
2901 Step S;
2902 S.Kind = SK_OCLSamplerInit;
2903 S.Type = T;
2904 Steps.push_back(S);
2905}
2906
Guy Benyeie6b9d802013-01-20 12:31:11 +00002907void InitializationSequence::AddOCLZeroEventStep(QualType T) {
2908 Step S;
2909 S.Kind = SK_OCLZeroEvent;
2910 S.Type = T;
2911 Steps.push_back(S);
2912}
2913
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002914void InitializationSequence::RewrapReferenceInitList(QualType T,
2915 InitListExpr *Syntactic) {
2916 assert(Syntactic->getNumInits() == 1 &&
2917 "Can only rewrap trivial init lists.");
2918 Step S;
2919 S.Kind = SK_UnwrapInitList;
2920 S.Type = Syntactic->getInit(0)->getType();
2921 Steps.insert(Steps.begin(), S);
2922
2923 S.Kind = SK_RewrapInitList;
2924 S.Type = T;
2925 S.WrappingSyntacticList = Syntactic;
2926 Steps.push_back(S);
2927}
2928
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002929void InitializationSequence::SetOverloadFailure(FailureKind Failure,
Douglas Gregor20093b42009-12-09 23:02:17 +00002930 OverloadingResult Result) {
Sebastian Redl7491c492011-06-05 13:59:11 +00002931 setSequenceKind(FailedSequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00002932 this->Failure = Failure;
2933 this->FailedOverloadResult = Result;
2934}
2935
2936//===----------------------------------------------------------------------===//
2937// Attempt initialization
2938//===----------------------------------------------------------------------===//
2939
John McCallf85e1932011-06-15 23:02:42 +00002940static void MaybeProduceObjCObject(Sema &S,
2941 InitializationSequence &Sequence,
2942 const InitializedEntity &Entity) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002943 if (!S.getLangOpts().ObjCAutoRefCount) return;
John McCallf85e1932011-06-15 23:02:42 +00002944
2945 /// When initializing a parameter, produce the value if it's marked
2946 /// __attribute__((ns_consumed)).
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002947 if (Entity.isParameterKind()) {
John McCallf85e1932011-06-15 23:02:42 +00002948 if (!Entity.isParameterConsumed())
2949 return;
2950
2951 assert(Entity.getType()->isObjCRetainableType() &&
2952 "consuming an object of unretainable type?");
2953 Sequence.AddProduceObjCObjectStep(Entity.getType());
2954
2955 /// When initializing a return value, if the return type is a
2956 /// retainable type, then returns need to immediately retain the
2957 /// object. If an autorelease is required, it will be done at the
2958 /// last instant.
2959 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
2960 if (!Entity.getType()->isObjCRetainableType())
2961 return;
2962
2963 Sequence.AddProduceObjCObjectStep(Entity.getType());
2964 }
2965}
2966
Richard Smith7c3e6152013-06-12 22:31:48 +00002967static void TryListInitialization(Sema &S,
2968 const InitializedEntity &Entity,
2969 const InitializationKind &Kind,
2970 InitListExpr *InitList,
2971 InitializationSequence &Sequence);
2972
Richard Smithf4bb8d02012-07-05 08:39:21 +00002973/// \brief When initializing from init list via constructor, handle
2974/// initialization of an object of type std::initializer_list<T>.
Sebastian Redl10f04a62011-12-22 14:44:04 +00002975///
Richard Smithf4bb8d02012-07-05 08:39:21 +00002976/// \return true if we have handled initialization of an object of type
2977/// std::initializer_list<T>, false otherwise.
2978static bool TryInitializerListConstruction(Sema &S,
2979 InitListExpr *List,
2980 QualType DestType,
2981 InitializationSequence &Sequence) {
2982 QualType E;
2983 if (!S.isStdInitializerList(DestType, &E))
Richard Smith1d0c9a82012-02-14 21:14:13 +00002984 return false;
2985
Richard Smith7c3e6152013-06-12 22:31:48 +00002986 if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
2987 Sequence.setIncompleteTypeFailure(E);
2988 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002989 }
Richard Smith7c3e6152013-06-12 22:31:48 +00002990
2991 // Try initializing a temporary array from the init list.
2992 QualType ArrayType = S.Context.getConstantArrayType(
2993 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
2994 List->getNumInits()),
2995 clang::ArrayType::Normal, 0);
2996 InitializedEntity HiddenArray =
2997 InitializedEntity::InitializeTemporary(ArrayType);
2998 InitializationKind Kind =
2999 InitializationKind::CreateDirectList(List->getExprLoc());
3000 TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3001 if (Sequence)
3002 Sequence.AddStdInitializerListConstructionStep(DestType);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003003 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003004}
3005
Sebastian Redl96715b22012-02-04 21:27:39 +00003006static OverloadingResult
3007ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003008 MultiExprArg Args,
Sebastian Redl96715b22012-02-04 21:27:39 +00003009 OverloadCandidateSet &CandidateSet,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003010 ArrayRef<NamedDecl *> Ctors,
Sebastian Redl96715b22012-02-04 21:27:39 +00003011 OverloadCandidateSet::iterator &Best,
3012 bool CopyInitializing, bool AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003013 bool OnlyListConstructors, bool InitListSyntax) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003014 CandidateSet.clear();
3015
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003016 for (ArrayRef<NamedDecl *>::iterator
3017 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003018 NamedDecl *D = *Con;
3019 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3020 bool SuppressUserConversions = false;
3021
3022 // Find the constructor (which may be a template).
3023 CXXConstructorDecl *Constructor = 0;
3024 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3025 if (ConstructorTmpl)
3026 Constructor = cast<CXXConstructorDecl>(
3027 ConstructorTmpl->getTemplatedDecl());
3028 else {
3029 Constructor = cast<CXXConstructorDecl>(D);
3030
Richard Smith867521c2013-09-21 21:23:47 +00003031 // C++11 [over.best.ics]p4:
3032 // However, when considering the argument of a constructor or
3033 // user-defined conversion function that is a candidate:
3034 // -- by 13.3.1.3 when invoked for the copying/moving of a temporary
3035 // in the second step of a class copy-initialization,
3036 // -- by 13.3.1.7 when passing the initializer list as a single
3037 // argument or when the initializer list has exactly one elementand
3038 // a conversion to some class X or reference to (possibly
3039 // cv-qualified) X is considered for the first parameter of a
3040 // constructor of X, or
3041 // -- by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases,
3042 // only standard conversion sequences and ellipsis conversion sequences
3043 // are considered.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003044 if ((CopyInitializing || (InitListSyntax && Args.size() == 1)) &&
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003045 Constructor->isCopyOrMoveConstructor())
Sebastian Redl96715b22012-02-04 21:27:39 +00003046 SuppressUserConversions = true;
3047 }
3048
3049 if (!Constructor->isInvalidDecl() &&
3050 (AllowExplicit || !Constructor->isExplicit()) &&
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003051 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003052 if (ConstructorTmpl)
3053 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003054 /*ExplicitArgs*/ 0, Args,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003055 CandidateSet, SuppressUserConversions);
Douglas Gregored878af2012-02-24 23:56:31 +00003056 else {
3057 // C++ [over.match.copy]p1:
3058 // - When initializing a temporary to be bound to the first parameter
3059 // of a constructor that takes a reference to possibly cv-qualified
3060 // T as its first argument, called with a single argument in the
3061 // context of direct-initialization, explicit conversion functions
3062 // are also considered.
3063 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003064 Args.size() == 1 &&
Douglas Gregored878af2012-02-24 23:56:31 +00003065 Constructor->isCopyOrMoveConstructor();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003066 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
Douglas Gregored878af2012-02-24 23:56:31 +00003067 SuppressUserConversions,
3068 /*PartialOverloading=*/false,
3069 /*AllowExplicit=*/AllowExplicitConv);
3070 }
Sebastian Redl96715b22012-02-04 21:27:39 +00003071 }
3072 }
3073
3074 // Perform overload resolution and return the result.
3075 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3076}
3077
Sebastian Redl10f04a62011-12-22 14:44:04 +00003078/// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3079/// enumerates the constructors of the initialized entity and performs overload
3080/// resolution to select the best.
Sebastian Redl08ae3692012-02-04 21:27:33 +00003081/// If InitListSyntax is true, this is list-initialization of a non-aggregate
Sebastian Redl10f04a62011-12-22 14:44:04 +00003082/// class type.
3083static void TryConstructorInitialization(Sema &S,
3084 const InitializedEntity &Entity,
3085 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003086 MultiExprArg Args, QualType DestType,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003087 InitializationSequence &Sequence,
Sebastian Redl08ae3692012-02-04 21:27:33 +00003088 bool InitListSyntax = false) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003089 assert((!InitListSyntax || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
Sebastian Redl08ae3692012-02-04 21:27:33 +00003090 "InitListSyntax must come with a single initializer list argument.");
3091
Sebastian Redl10f04a62011-12-22 14:44:04 +00003092 // The type we're constructing needs to be complete.
3093 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003094 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redl96715b22012-02-04 21:27:39 +00003095 return;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003096 }
3097
3098 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3099 assert(DestRecordType && "Constructor initialization requires record type");
3100 CXXRecordDecl *DestRecordDecl
3101 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3102
Sebastian Redl96715b22012-02-04 21:27:39 +00003103 // Build the candidate set directly in the initialization sequence
3104 // structure, so that it will persist if we fail.
3105 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3106
3107 // Determine whether we are allowed to call explicit constructors or
3108 // explicit conversion operators.
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003109 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003110 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
Sebastian Redl08ae3692012-02-04 21:27:33 +00003111
Sebastian Redl10f04a62011-12-22 14:44:04 +00003112 // - Otherwise, if T is a class type, constructors are considered. The
3113 // applicable constructors are enumerated, and the best one is chosen
3114 // through overload resolution.
David Blaikie3bc93e32012-12-19 00:45:41 +00003115 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003116 // The container holding the constructors can under certain conditions
3117 // be changed while iterating (e.g. because of deserialization).
3118 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003119 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Sebastian Redl10f04a62011-12-22 14:44:04 +00003120
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003121 OverloadingResult Result = OR_No_Viable_Function;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003122 OverloadCandidateSet::iterator Best;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003123 bool AsInitializerList = false;
3124
3125 // C++11 [over.match.list]p1:
3126 // When objects of non-aggregate type T are list-initialized, overload
3127 // resolution selects the constructor in two phases:
3128 // - Initially, the candidate functions are the initializer-list
3129 // constructors of the class T and the argument list consists of the
3130 // initializer list as a single argument.
3131 if (InitListSyntax) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003132 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003133 AsInitializerList = true;
Richard Smithf4bb8d02012-07-05 08:39:21 +00003134
3135 // If the initializer list has no elements and T has a default constructor,
3136 // the first phase is omitted.
Richard Smithe5411b72012-12-01 02:35:44 +00003137 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003138 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003139 CandidateSet, Ctors, Best,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003140 CopyInitialization, AllowExplicit,
3141 /*OnlyListConstructor=*/true,
3142 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003143
3144 // Time to unwrap the init list.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003145 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003146 }
3147
3148 // C++11 [over.match.list]p1:
3149 // - If no viable initializer-list constructor is found, overload resolution
3150 // is performed again, where the candidate functions are all the
Richard Smithf4bb8d02012-07-05 08:39:21 +00003151 // constructors of the class T and the argument list consists of the
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003152 // elements of the initializer list.
3153 if (Result == OR_No_Viable_Function) {
3154 AsInitializerList = false;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003155 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003156 CandidateSet, Ctors, Best,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003157 CopyInitialization, AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003158 /*OnlyListConstructors=*/false,
3159 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003160 }
3161 if (Result) {
Sebastian Redl08ae3692012-02-04 21:27:33 +00003162 Sequence.SetOverloadFailure(InitListSyntax ?
Sebastian Redlcf15cef2011-12-22 18:58:38 +00003163 InitializationSequence::FK_ListConstructorOverloadFailed :
3164 InitializationSequence::FK_ConstructorOverloadFailed,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003165 Result);
3166 return;
3167 }
3168
Richard Smithf4bb8d02012-07-05 08:39:21 +00003169 // C++11 [dcl.init]p6:
Sebastian Redl10f04a62011-12-22 14:44:04 +00003170 // If a program calls for the default initialization of an object
3171 // of a const-qualified type T, T shall be a class type with a
3172 // user-provided default constructor.
3173 if (Kind.getKind() == InitializationKind::IK_Default &&
3174 Entity.getType().isConstQualified() &&
Aaron Ballman51217812012-07-31 22:40:31 +00003175 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00003176 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3177 return;
3178 }
3179
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003180 // C++11 [over.match.list]p1:
3181 // In copy-list-initialization, if an explicit constructor is chosen, the
3182 // initializer is ill-formed.
3183 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3184 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3185 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3186 return;
3187 }
3188
Sebastian Redl10f04a62011-12-22 14:44:04 +00003189 // Add the constructor initialization step. Any cv-qualification conversion is
3190 // subsumed by the initialization.
3191 bool HadMultipleCandidates = (CandidateSet.size() > 1);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003192 Sequence.AddConstructorInitializationStep(CtorDecl,
3193 Best->FoundDecl.getAccess(),
3194 DestType, HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003195 InitListSyntax, AsInitializerList);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003196}
3197
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003198static bool
3199ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3200 Expr *Initializer,
3201 QualType &SourceType,
3202 QualType &UnqualifiedSourceType,
3203 QualType UnqualifiedTargetType,
3204 InitializationSequence &Sequence) {
3205 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3206 S.Context.OverloadTy) {
3207 DeclAccessPair Found;
3208 bool HadMultipleCandidates = false;
3209 if (FunctionDecl *Fn
3210 = S.ResolveAddressOfOverloadedFunction(Initializer,
3211 UnqualifiedTargetType,
3212 false, Found,
3213 &HadMultipleCandidates)) {
3214 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3215 HadMultipleCandidates);
3216 SourceType = Fn->getType();
3217 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3218 } else if (!UnqualifiedTargetType->isRecordType()) {
3219 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3220 return true;
3221 }
3222 }
3223 return false;
3224}
3225
3226static void TryReferenceInitializationCore(Sema &S,
3227 const InitializedEntity &Entity,
3228 const InitializationKind &Kind,
3229 Expr *Initializer,
3230 QualType cv1T1, QualType T1,
3231 Qualifiers T1Quals,
3232 QualType cv2T2, QualType T2,
3233 Qualifiers T2Quals,
3234 InitializationSequence &Sequence);
3235
Richard Smithf4bb8d02012-07-05 08:39:21 +00003236static void TryValueInitialization(Sema &S,
3237 const InitializedEntity &Entity,
3238 const InitializationKind &Kind,
3239 InitializationSequence &Sequence,
3240 InitListExpr *InitList = 0);
3241
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003242/// \brief Attempt list initialization of a reference.
3243static void TryReferenceListInitialization(Sema &S,
3244 const InitializedEntity &Entity,
3245 const InitializationKind &Kind,
3246 InitListExpr *InitList,
Richard Smithb6e38082013-06-08 00:02:08 +00003247 InitializationSequence &Sequence) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003248 // First, catch C++03 where this isn't possible.
Richard Smith80ad52f2013-01-02 11:42:31 +00003249 if (!S.getLangOpts().CPlusPlus11) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003250 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3251 return;
3252 }
3253
3254 QualType DestType = Entity.getType();
3255 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3256 Qualifiers T1Quals;
3257 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3258
3259 // Reference initialization via an initializer list works thus:
3260 // If the initializer list consists of a single element that is
3261 // reference-related to the referenced type, bind directly to that element
3262 // (possibly creating temporaries).
3263 // Otherwise, initialize a temporary with the initializer list and
3264 // bind to that.
3265 if (InitList->getNumInits() == 1) {
3266 Expr *Initializer = InitList->getInit(0);
3267 QualType cv2T2 = Initializer->getType();
3268 Qualifiers T2Quals;
3269 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3270
3271 // If this fails, creating a temporary wouldn't work either.
3272 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3273 T1, Sequence))
3274 return;
3275
3276 SourceLocation DeclLoc = Initializer->getLocStart();
3277 bool dummy1, dummy2, dummy3;
3278 Sema::ReferenceCompareResult RefRelationship
3279 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3280 dummy2, dummy3);
3281 if (RefRelationship >= Sema::Ref_Related) {
3282 // Try to bind the reference here.
3283 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3284 T1Quals, cv2T2, T2, T2Quals, Sequence);
3285 if (Sequence)
3286 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3287 return;
3288 }
Richard Smith02d65ee2013-01-15 07:58:29 +00003289
3290 // Update the initializer if we've resolved an overloaded function.
3291 if (Sequence.step_begin() != Sequence.step_end())
3292 Sequence.RewrapReferenceInitList(cv1T1, InitList);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003293 }
3294
3295 // Not reference-related. Create a temporary and bind to that.
3296 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3297
3298 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3299 if (Sequence) {
3300 if (DestType->isRValueReferenceType() ||
3301 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3302 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3303 else
3304 Sequence.SetFailed(
3305 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3306 }
3307}
3308
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003309/// \brief Attempt list initialization (C++0x [dcl.init.list])
3310static void TryListInitialization(Sema &S,
3311 const InitializedEntity &Entity,
3312 const InitializationKind &Kind,
3313 InitListExpr *InitList,
3314 InitializationSequence &Sequence) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003315 QualType DestType = Entity.getType();
3316
Sebastian Redl14b0c192011-09-24 17:48:00 +00003317 // C++ doesn't allow scalar initialization with more than one argument.
3318 // But C99 complex numbers are scalars and it makes sense there.
David Blaikie4e4d0842012-03-11 07:00:24 +00003319 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
Sebastian Redl14b0c192011-09-24 17:48:00 +00003320 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3321 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3322 return;
3323 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00003324 if (DestType->isReferenceType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003325 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003326 return;
Sebastian Redl14b0c192011-09-24 17:48:00 +00003327 }
Sebastian Redld2231c92012-02-19 12:27:43 +00003328 if (DestType->isRecordType()) {
Douglas Gregord10099e2012-05-04 16:32:21 +00003329 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003330 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redld2231c92012-02-19 12:27:43 +00003331 return;
3332 }
3333
Richard Smithf4bb8d02012-07-05 08:39:21 +00003334 // C++11 [dcl.init.list]p3:
3335 // - If T is an aggregate, aggregate initialization is performed.
Sebastian Redld2231c92012-02-19 12:27:43 +00003336 if (!DestType->isAggregateType()) {
Richard Smith80ad52f2013-01-02 11:42:31 +00003337 if (S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003338 // - Otherwise, if the initializer list has no elements and T is a
3339 // class type with a default constructor, the object is
3340 // value-initialized.
3341 if (InitList->getNumInits() == 0) {
3342 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
Richard Smithe5411b72012-12-01 02:35:44 +00003343 if (RD->hasDefaultConstructor()) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003344 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3345 return;
3346 }
3347 }
3348
3349 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3350 // an initializer_list object constructed [...]
3351 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3352 return;
3353
3354 // - Otherwise, if T is a class type, constructors are considered.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003355 Expr *InitListAsExpr = InitList;
3356 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003357 Sequence, /*InitListSyntax*/true);
Sebastian Redld2231c92012-02-19 12:27:43 +00003358 } else
3359 Sequence.SetFailed(
3360 InitializationSequence::FK_InitListBadDestinationType);
3361 return;
3362 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003363 }
Richard Smithb390e492013-09-21 21:55:46 +00003364 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3365 InitList->getNumInits() == 1 &&
3366 InitList->getInit(0)->getType()->isRecordType()) {
3367 // - Otherwise, if the initializer list has a single element of type E
3368 // [...references are handled above...], the object or reference is
3369 // initialized from that element; if a narrowing conversion is required
3370 // to convert the element to T, the program is ill-formed.
3371 //
3372 // Per core-24034, this is direct-initialization if we were performing
3373 // direct-list-initialization and copy-initialization otherwise.
3374 // We can't use InitListChecker for this, because it always performs
3375 // copy-initialization. This only matters if we might use an 'explicit'
3376 // conversion operator, so we only need to handle the cases where the source
3377 // is of record type.
3378 InitializationKind SubKind =
3379 Kind.getKind() == InitializationKind::IK_DirectList
3380 ? InitializationKind::CreateDirect(Kind.getLocation(),
3381 InitList->getLBraceLoc(),
3382 InitList->getRBraceLoc())
3383 : Kind;
3384 Expr *SubInit[1] = { InitList->getInit(0) };
3385 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3386 /*TopLevelOfInitList*/true);
3387 if (Sequence)
3388 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3389 return;
3390 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003391
Sebastian Redl14b0c192011-09-24 17:48:00 +00003392 InitListChecker CheckInitList(S, Entity, InitList,
Richard Smith40cba902013-06-06 11:41:05 +00003393 DestType, /*VerifyOnly=*/true);
Sebastian Redl14b0c192011-09-24 17:48:00 +00003394 if (CheckInitList.HadError()) {
3395 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3396 return;
3397 }
3398
3399 // Add the list initialization step with the built init list.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003400 Sequence.AddListInitializationStep(DestType);
3401}
Douglas Gregor20093b42009-12-09 23:02:17 +00003402
3403/// \brief Try a reference initialization that involves calling a conversion
3404/// function.
Douglas Gregor20093b42009-12-09 23:02:17 +00003405static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3406 const InitializedEntity &Entity,
3407 const InitializationKind &Kind,
Douglas Gregored878af2012-02-24 23:56:31 +00003408 Expr *Initializer,
3409 bool AllowRValues,
Douglas Gregor20093b42009-12-09 23:02:17 +00003410 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003411 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003412 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3413 QualType T1 = cv1T1.getUnqualifiedType();
3414 QualType cv2T2 = Initializer->getType();
3415 QualType T2 = cv2T2.getUnqualifiedType();
3416
3417 bool DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003418 bool ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003419 bool ObjCLifetimeConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003420 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
Douglas Gregor569c3162010-08-07 11:51:51 +00003421 T1, T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003422 ObjCConversion,
3423 ObjCLifetimeConversion) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003424 "Must have incompatible references when binding via conversion");
Chandler Carruth60cfcec2009-12-13 01:37:04 +00003425 (void)DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003426 (void)ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003427 (void)ObjCLifetimeConversion;
3428
Douglas Gregor20093b42009-12-09 23:02:17 +00003429 // Build the candidate set directly in the initialization sequence
3430 // structure, so that it will persist if we fail.
3431 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3432 CandidateSet.clear();
3433
3434 // Determine whether we are allowed to call explicit constructors or
3435 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003436 bool AllowExplicit = Kind.AllowExplicit();
Richard Smith867521c2013-09-21 21:23:47 +00003437 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3438
Douglas Gregor20093b42009-12-09 23:02:17 +00003439 const RecordType *T1RecordType = 0;
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003440 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3441 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003442 // The type we're converting to is a class type. Enumerate its constructors
3443 // to see if there is a suitable conversion.
3444 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
John McCall572fc622010-08-17 07:23:57 +00003445
David Blaikie3bc93e32012-12-19 00:45:41 +00003446 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003447 // The container holding the constructors can under certain conditions
3448 // be changed while iterating (e.g. because of deserialization).
3449 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003450 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00003451 for (SmallVectorImpl<NamedDecl *>::iterator
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003452 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3453 NamedDecl *D = *CI;
John McCall9aa472c2010-03-19 07:35:19 +00003454 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3455
Douglas Gregor20093b42009-12-09 23:02:17 +00003456 // Find the constructor (which may be a template).
3457 CXXConstructorDecl *Constructor = 0;
John McCall9aa472c2010-03-19 07:35:19 +00003458 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor20093b42009-12-09 23:02:17 +00003459 if (ConstructorTmpl)
3460 Constructor = cast<CXXConstructorDecl>(
3461 ConstructorTmpl->getTemplatedDecl());
3462 else
John McCall9aa472c2010-03-19 07:35:19 +00003463 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003464
Douglas Gregor20093b42009-12-09 23:02:17 +00003465 if (!Constructor->isInvalidDecl() &&
3466 Constructor->isConvertingConstructor(AllowExplicit)) {
3467 if (ConstructorTmpl)
John McCall9aa472c2010-03-19 07:35:19 +00003468 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
John McCall86820f52010-01-26 01:37:31 +00003469 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003470 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003471 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003472 else
John McCall9aa472c2010-03-19 07:35:19 +00003473 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003474 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003475 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003476 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003477 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003478 }
John McCall572fc622010-08-17 07:23:57 +00003479 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3480 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003481
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003482 const RecordType *T2RecordType = 0;
3483 if ((T2RecordType = T2->getAs<RecordType>()) &&
3484 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003485 // The type we're converting from is a class type, enumerate its conversion
3486 // functions.
3487 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3488
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00003489 std::pair<CXXRecordDecl::conversion_iterator,
3490 CXXRecordDecl::conversion_iterator>
3491 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3492 for (CXXRecordDecl::conversion_iterator
3493 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003494 NamedDecl *D = *I;
3495 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3496 if (isa<UsingShadowDecl>(D))
3497 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003498
Douglas Gregor20093b42009-12-09 23:02:17 +00003499 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3500 CXXConversionDecl *Conv;
3501 if (ConvTemplate)
3502 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3503 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003504 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003505
Douglas Gregor20093b42009-12-09 23:02:17 +00003506 // If the conversion function doesn't return a reference type,
3507 // it can't be considered for this conversion unless we're allowed to
3508 // consider rvalues.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003509 // FIXME: Do we need to make sure that we only consider conversion
3510 // candidates with reference-compatible results? That might be needed to
Douglas Gregor20093b42009-12-09 23:02:17 +00003511 // break recursion.
Douglas Gregored878af2012-02-24 23:56:31 +00003512 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003513 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3514 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00003515 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00003516 ActingDC, Initializer,
Stephen Hines651f13c2014-04-23 16:59:28 -07003517 DestType, CandidateSet,
3518 /*AllowObjCConversionOnExplicit=*/
3519 false);
Douglas Gregor20093b42009-12-09 23:02:17 +00003520 else
John McCall9aa472c2010-03-19 07:35:19 +00003521 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Stephen Hines651f13c2014-04-23 16:59:28 -07003522 Initializer, DestType, CandidateSet,
3523 /*AllowObjCConversionOnExplicit=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00003524 }
3525 }
3526 }
John McCall572fc622010-08-17 07:23:57 +00003527 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3528 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003529
Douglas Gregor20093b42009-12-09 23:02:17 +00003530 SourceLocation DeclLoc = Initializer->getLocStart();
3531
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003532 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor20093b42009-12-09 23:02:17 +00003533 OverloadCandidateSet::iterator Best;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003534 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00003535 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
Douglas Gregor20093b42009-12-09 23:02:17 +00003536 return Result;
Eli Friedman03981012009-12-11 02:42:07 +00003537
Douglas Gregor20093b42009-12-09 23:02:17 +00003538 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00003539 // This is the overload that will be used for this initialization step if we
3540 // use this initialization. Mark it as referenced.
3541 Function->setReferenced();
Chandler Carruth25ca4212011-02-25 19:41:05 +00003542
Eli Friedman03981012009-12-11 02:42:07 +00003543 // Compute the returned type of the conversion.
Douglas Gregor20093b42009-12-09 23:02:17 +00003544 if (isa<CXXConversionDecl>(Function))
Stephen Hines651f13c2014-04-23 16:59:28 -07003545 T2 = Function->getReturnType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003546 else
3547 T2 = cv1T1;
Eli Friedman03981012009-12-11 02:42:07 +00003548
3549 // Add the user-defined conversion step.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003550 bool HadMultipleCandidates = (CandidateSet.size() > 1);
John McCall9aa472c2010-03-19 07:35:19 +00003551 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003552 T2.getNonLValueExprType(S.Context),
3553 HadMultipleCandidates);
Eli Friedman03981012009-12-11 02:42:07 +00003554
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003555 // Determine whether we need to perform derived-to-base or
Eli Friedman03981012009-12-11 02:42:07 +00003556 // cv-qualification adjustments.
John McCall5baba9d2010-08-25 10:28:54 +00003557 ExprValueKind VK = VK_RValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003558 if (T2->isLValueReferenceType())
John McCall5baba9d2010-08-25 10:28:54 +00003559 VK = VK_LValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003560 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
John McCall5baba9d2010-08-25 10:28:54 +00003561 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003562
Douglas Gregor20093b42009-12-09 23:02:17 +00003563 bool NewDerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003564 bool NewObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003565 bool NewObjCLifetimeConversion = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00003566 Sema::ReferenceCompareResult NewRefRelationship
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003567 = S.CompareReferenceRelationship(DeclLoc, T1,
Douglas Gregor63982352010-07-13 18:40:04 +00003568 T2.getNonLValueExprType(S.Context),
John McCallf85e1932011-06-15 23:02:42 +00003569 NewDerivedToBase, NewObjCConversion,
3570 NewObjCLifetimeConversion);
Douglas Gregora1a9f032010-03-07 23:17:44 +00003571 if (NewRefRelationship == Sema::Ref_Incompatible) {
3572 // If the type we've converted to is not reference-related to the
3573 // type we're looking for, then there is another conversion step
3574 // we need to perform to produce a temporary of the right type
3575 // that we'll be binding to.
3576 ImplicitConversionSequence ICS;
3577 ICS.setStandard();
3578 ICS.Standard = Best->FinalConversion;
3579 T2 = ICS.Standard.getToType(2);
3580 Sequence.AddConversionSequenceStep(ICS, T2);
3581 } else if (NewDerivedToBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00003582 Sequence.AddDerivedToBaseCastStep(
3583 S.Context.getQualifiedType(T1,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003584 T2.getNonReferenceType().getQualifiers()),
John McCall5baba9d2010-08-25 10:28:54 +00003585 VK);
Douglas Gregor569c3162010-08-07 11:51:51 +00003586 else if (NewObjCConversion)
3587 Sequence.AddObjCObjectConversionStep(
3588 S.Context.getQualifiedType(T1,
3589 T2.getNonReferenceType().getQualifiers()));
3590
Douglas Gregor20093b42009-12-09 23:02:17 +00003591 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
John McCall5baba9d2010-08-25 10:28:54 +00003592 Sequence.AddQualificationConversionStep(cv1T1, VK);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003593
Douglas Gregor20093b42009-12-09 23:02:17 +00003594 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3595 return OR_Success;
3596}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003597
Richard Smith83da2e72011-10-19 16:55:56 +00003598static void CheckCXX98CompatAccessibleCopy(Sema &S,
3599 const InitializedEntity &Entity,
3600 Expr *CurInitExpr);
3601
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003602/// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3603static void TryReferenceInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003604 const InitializedEntity &Entity,
3605 const InitializationKind &Kind,
3606 Expr *Initializer,
3607 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003608 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003609 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003610 Qualifiers T1Quals;
3611 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
Douglas Gregor20093b42009-12-09 23:02:17 +00003612 QualType cv2T2 = Initializer->getType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003613 Qualifiers T2Quals;
3614 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003615
Douglas Gregor20093b42009-12-09 23:02:17 +00003616 // If the initializer is the address of an overloaded function, try
3617 // to resolve the overloaded function. If all goes well, T2 is the
3618 // type of the resulting function.
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003619 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3620 T1, Sequence))
3621 return;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003622
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003623 // Delegate everything else to a subfunction.
3624 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3625 T1Quals, cv2T2, T2, T2Quals, Sequence);
3626}
3627
Jordan Rose1fd1e282013-04-11 00:58:58 +00003628/// Converts the target of reference initialization so that it has the
3629/// appropriate qualifiers and value kind.
3630///
3631/// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
3632/// \code
3633/// int x;
3634/// const int &r = x;
3635/// \endcode
3636///
3637/// In this case the reference is binding to a bitfield lvalue, which isn't
3638/// valid. Perform a load to create a lifetime-extended temporary instead.
3639/// \code
3640/// const int &r = someStruct.bitfield;
3641/// \endcode
3642static ExprValueKind
3643convertQualifiersAndValueKindIfNecessary(Sema &S,
3644 InitializationSequence &Sequence,
3645 Expr *Initializer,
3646 QualType cv1T1,
3647 Qualifiers T1Quals,
3648 Qualifiers T2Quals,
3649 bool IsLValueRef) {
John McCall993f43f2013-05-06 21:39:12 +00003650 bool IsNonAddressableType = Initializer->refersToBitField() ||
Jordan Rose1fd1e282013-04-11 00:58:58 +00003651 Initializer->refersToVectorElement();
3652
3653 if (IsNonAddressableType) {
3654 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
3655 // lvalue reference to a non-volatile const type, or the reference shall be
3656 // an rvalue reference.
3657 //
3658 // If not, we can't make a temporary and bind to that. Give up and allow the
3659 // error to be diagnosed later.
3660 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
3661 assert(Initializer->isGLValue());
3662 return Initializer->getValueKind();
3663 }
3664
3665 // Force a load so we can materialize a temporary.
3666 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
3667 return VK_RValue;
3668 }
3669
3670 if (T1Quals != T2Quals) {
3671 Sequence.AddQualificationConversionStep(cv1T1,
3672 Initializer->getValueKind());
3673 }
3674
3675 return Initializer->getValueKind();
3676}
3677
3678
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003679/// \brief Reference initialization without resolving overloaded functions.
3680static void TryReferenceInitializationCore(Sema &S,
3681 const InitializedEntity &Entity,
3682 const InitializationKind &Kind,
3683 Expr *Initializer,
3684 QualType cv1T1, QualType T1,
3685 Qualifiers T1Quals,
3686 QualType cv2T2, QualType T2,
3687 Qualifiers T2Quals,
3688 InitializationSequence &Sequence) {
3689 QualType DestType = Entity.getType();
3690 SourceLocation DeclLoc = Initializer->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00003691 // Compute some basic properties of the types and the initializer.
3692 bool isLValueRef = DestType->isLValueReferenceType();
3693 bool isRValueRef = !isLValueRef;
3694 bool DerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003695 bool ObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003696 bool ObjCLifetimeConversion = false;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003697 Expr::Classification InitCategory = Initializer->Classify(S.Context);
Douglas Gregor20093b42009-12-09 23:02:17 +00003698 Sema::ReferenceCompareResult RefRelationship
Douglas Gregor569c3162010-08-07 11:51:51 +00003699 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003700 ObjCConversion, ObjCLifetimeConversion);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003701
Douglas Gregor20093b42009-12-09 23:02:17 +00003702 // C++0x [dcl.init.ref]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003703 // A reference to type "cv1 T1" is initialized by an expression of type
Douglas Gregor20093b42009-12-09 23:02:17 +00003704 // "cv2 T2" as follows:
3705 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003706 // - If the reference is an lvalue reference and the initializer
Douglas Gregor20093b42009-12-09 23:02:17 +00003707 // expression
Richard Smith867521c2013-09-21 21:23:47 +00003708 // Note the analogous bullet points for rvalue refs to functions. Because
Sebastian Redl4680bf22010-06-30 18:13:39 +00003709 // there are no function rvalues in C++, rvalue refs to functions are treated
3710 // like lvalue refs.
Douglas Gregor20093b42009-12-09 23:02:17 +00003711 OverloadingResult ConvOvlResult = OR_Success;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003712 bool T1Function = T1->isFunctionType();
3713 if (isLValueRef || T1Function) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003714 if (InitCategory.isLValue() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003715 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003716 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003717 RefRelationship == Sema::Ref_Related))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003718 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
Douglas Gregor20093b42009-12-09 23:02:17 +00003719 // reference-compatible with "cv2 T2," or
3720 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003721 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
Douglas Gregor20093b42009-12-09 23:02:17 +00003722 // bit-field when we're determining whether the reference initialization
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003723 // can occur. However, we do pay attention to whether it is a bit-field
3724 // to decide whether we're actually binding to a temporary created from
3725 // the bit-field.
Douglas Gregor20093b42009-12-09 23:02:17 +00003726 if (DerivedToBase)
3727 Sequence.AddDerivedToBaseCastStep(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003728 S.Context.getQualifiedType(T1, T2Quals),
John McCall5baba9d2010-08-25 10:28:54 +00003729 VK_LValue);
Douglas Gregor569c3162010-08-07 11:51:51 +00003730 else if (ObjCConversion)
3731 Sequence.AddObjCObjectConversionStep(
3732 S.Context.getQualifiedType(T1, T2Quals));
3733
Jordan Rose1fd1e282013-04-11 00:58:58 +00003734 ExprValueKind ValueKind =
3735 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
3736 cv1T1, T1Quals, T2Quals,
3737 isLValueRef);
3738 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
Douglas Gregor20093b42009-12-09 23:02:17 +00003739 return;
3740 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003741
3742 // - has a class type (i.e., T2 is a class type), where T1 is not
3743 // reference-related to T2, and can be implicitly converted to an
3744 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3745 // with "cv3 T3" (this conversion is selected by enumerating the
Douglas Gregor20093b42009-12-09 23:02:17 +00003746 // applicable conversion functions (13.3.1.6) and choosing the best
3747 // one through overload resolution (13.3)),
Sebastian Redl4680bf22010-06-30 18:13:39 +00003748 // If we have an rvalue ref to function type here, the rhs must be
Richard Smith867521c2013-09-21 21:23:47 +00003749 // an rvalue. DR1287 removed the "implicitly" here.
Sebastian Redl4680bf22010-06-30 18:13:39 +00003750 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3751 (isLValueRef || InitCategory.isRValue())) {
Richard Smith867521c2013-09-21 21:23:47 +00003752 ConvOvlResult = TryRefInitWithConversionFunction(
3753 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00003754 if (ConvOvlResult == OR_Success)
3755 return;
Richard Smith867521c2013-09-21 21:23:47 +00003756 if (ConvOvlResult != OR_No_Viable_Function)
John McCall1d318332010-01-12 00:44:57 +00003757 Sequence.SetOverloadFailure(
Richard Smith867521c2013-09-21 21:23:47 +00003758 InitializationSequence::FK_ReferenceInitOverloadFailed,
3759 ConvOvlResult);
Douglas Gregor20093b42009-12-09 23:02:17 +00003760 }
3761 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003762
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003763 // - Otherwise, the reference shall be an lvalue reference to a
Douglas Gregor20093b42009-12-09 23:02:17 +00003764 // non-volatile const type (i.e., cv1 shall be const), or the reference
Douglas Gregor69d83162011-01-20 16:08:06 +00003765 // shall be an rvalue reference.
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003766 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
Douglas Gregor3afb9772010-11-08 15:20:28 +00003767 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3768 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3769 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
Douglas Gregor20093b42009-12-09 23:02:17 +00003770 Sequence.SetOverloadFailure(
3771 InitializationSequence::FK_ReferenceInitOverloadFailed,
3772 ConvOvlResult);
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003773 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003774 Sequence.SetFailed(InitCategory.isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00003775 ? (RefRelationship == Sema::Ref_Related
3776 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3777 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3778 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003779
Douglas Gregor20093b42009-12-09 23:02:17 +00003780 return;
3781 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003782
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003783 // - If the initializer expression
3784 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3785 // "cv1 T1" is reference-compatible with "cv2 T2"
3786 // Note: functions are handled below.
3787 if (!T1Function &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003788 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003789 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003790 RefRelationship == Sema::Ref_Related)) &&
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003791 (InitCategory.isXValue() ||
3792 (InitCategory.isPRValue() && T2->isRecordType()) ||
3793 (InitCategory.isPRValue() && T2->isArrayType()))) {
3794 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3795 if (InitCategory.isPRValue() && T2->isRecordType()) {
Douglas Gregor523d46a2010-04-18 07:40:54 +00003796 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3797 // compiler the freedom to perform a copy here or bind to the
3798 // object, while C++0x requires that we bind directly to the
3799 // object. Hence, we always bind to the object without making an
3800 // extra copy. However, in C++03 requires that we check for the
3801 // presence of a suitable copy constructor:
3802 //
3803 // The constructor that would be used to make the copy shall
3804 // be callable whether or not the copy is actually done.
Richard Smith80ad52f2013-01-02 11:42:31 +00003805 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
Douglas Gregor523d46a2010-04-18 07:40:54 +00003806 Sequence.AddExtraneousCopyToTemporary(cv2T2);
Richard Smith80ad52f2013-01-02 11:42:31 +00003807 else if (S.getLangOpts().CPlusPlus11)
Richard Smith83da2e72011-10-19 16:55:56 +00003808 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
Douglas Gregor20093b42009-12-09 23:02:17 +00003809 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003810
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003811 if (DerivedToBase)
3812 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3813 ValueKind);
3814 else if (ObjCConversion)
3815 Sequence.AddObjCObjectConversionStep(
3816 S.Context.getQualifiedType(T1, T2Quals));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003817
Jordan Rose1fd1e282013-04-11 00:58:58 +00003818 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
3819 Initializer, cv1T1,
3820 T1Quals, T2Quals,
3821 isLValueRef);
3822
3823 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003824 return;
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003825 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003826
3827 // - has a class type (i.e., T2 is a class type), where T1 is not
3828 // reference-related to T2, and can be implicitly converted to an
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003829 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3830 // where "cv1 T1" is reference-compatible with "cv3 T3",
Richard Smith867521c2013-09-21 21:23:47 +00003831 //
3832 // DR1287 removes the "implicitly" here.
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003833 if (T2->isRecordType()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003834 if (RefRelationship == Sema::Ref_Incompatible) {
Richard Smith867521c2013-09-21 21:23:47 +00003835 ConvOvlResult = TryRefInitWithConversionFunction(
3836 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00003837 if (ConvOvlResult)
3838 Sequence.SetOverloadFailure(
Richard Smith867521c2013-09-21 21:23:47 +00003839 InitializationSequence::FK_ReferenceInitOverloadFailed,
3840 ConvOvlResult);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003841
Douglas Gregor20093b42009-12-09 23:02:17 +00003842 return;
3843 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003844
Douglas Gregordefa32e2013-03-26 23:59:23 +00003845 if ((RefRelationship == Sema::Ref_Compatible ||
3846 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
3847 isRValueRef && InitCategory.isLValue()) {
3848 Sequence.SetFailed(
3849 InitializationSequence::FK_RValueReferenceBindingToLValue);
3850 return;
3851 }
3852
Douglas Gregor20093b42009-12-09 23:02:17 +00003853 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3854 return;
3855 }
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003856
3857 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
Douglas Gregor20093b42009-12-09 23:02:17 +00003858 // from the initializer expression using the rules for a non-reference
Richard Smith4e47ecb2013-06-13 00:57:57 +00003859 // copy-initialization (8.5). The reference is then bound to the
Douglas Gregor20093b42009-12-09 23:02:17 +00003860 // temporary. [...]
John McCall369371c2010-06-04 02:29:22 +00003861
John McCall369371c2010-06-04 02:29:22 +00003862 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3863
Richard Smith4e47ecb2013-06-13 00:57:57 +00003864 // FIXME: Why do we use an implicit conversion here rather than trying
3865 // copy-initialization?
John McCallf85e1932011-06-15 23:02:42 +00003866 ImplicitConversionSequence ICS
3867 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
Richard Smith4e47ecb2013-06-13 00:57:57 +00003868 /*SuppressUserConversions=*/false,
3869 /*AllowExplicit=*/false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003870 /*FIXME:InOverloadResolution=*/false,
John McCallf85e1932011-06-15 23:02:42 +00003871 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3872 /*AllowObjCWritebackConversion=*/false);
3873
3874 if (ICS.isBad()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003875 // FIXME: Use the conversion function set stored in ICS to turn
3876 // this into an overloading ambiguity diagnostic. However, we need
3877 // to keep that set as an OverloadCandidateSet rather than as some
3878 // other kind of set.
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003879 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3880 Sequence.SetOverloadFailure(
3881 InitializationSequence::FK_ReferenceInitOverloadFailed,
3882 ConvOvlResult);
Douglas Gregor3afb9772010-11-08 15:20:28 +00003883 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3884 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003885 else
3886 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
Douglas Gregor20093b42009-12-09 23:02:17 +00003887 return;
John McCallf85e1932011-06-15 23:02:42 +00003888 } else {
3889 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003890 }
3891
3892 // [...] If T1 is reference-related to T2, cv1 must be the
3893 // same cv-qualification as, or greater cv-qualification
3894 // than, cv2; otherwise, the program is ill-formed.
Chandler Carruth5535c382010-01-12 20:32:25 +00003895 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3896 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003897 if (RefRelationship == Sema::Ref_Related &&
Chandler Carruth5535c382010-01-12 20:32:25 +00003898 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003899 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3900 return;
3901 }
3902
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003903 // [...] If T1 is reference-related to T2 and the reference is an rvalue
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003904 // reference, the initializer expression shall not be an lvalue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003905 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003906 InitCategory.isLValue()) {
3907 Sequence.SetFailed(
3908 InitializationSequence::FK_RValueReferenceBindingToLValue);
3909 return;
3910 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003911
Douglas Gregor20093b42009-12-09 23:02:17 +00003912 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3913 return;
3914}
3915
3916/// \brief Attempt character array initialization from a string literal
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003917/// (C++ [dcl.init.string], C99 6.7.8).
3918static void TryStringLiteralInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003919 const InitializedEntity &Entity,
3920 const InitializationKind &Kind,
3921 Expr *Initializer,
3922 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003923 Sequence.AddStringInitStep(Entity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003924}
3925
Douglas Gregor71d17402009-12-15 00:01:57 +00003926/// \brief Attempt value initialization (C++ [dcl.init]p7).
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003927static void TryValueInitialization(Sema &S,
Douglas Gregor71d17402009-12-15 00:01:57 +00003928 const InitializedEntity &Entity,
3929 const InitializationKind &Kind,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003930 InitializationSequence &Sequence,
3931 InitListExpr *InitList) {
3932 assert((!InitList || InitList->getNumInits() == 0) &&
3933 "Shouldn't use value-init for non-empty init lists");
3934
Richard Smith1d0c9a82012-02-14 21:14:13 +00003935 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
Douglas Gregor71d17402009-12-15 00:01:57 +00003936 //
3937 // To value-initialize an object of type T means:
Douglas Gregord6542d82009-12-22 15:35:07 +00003938 QualType T = Entity.getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003939
Douglas Gregor71d17402009-12-15 00:01:57 +00003940 // -- if T is an array type, then each element is value-initialized;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003941 T = S.Context.getBaseElementType(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003942
Douglas Gregor71d17402009-12-15 00:01:57 +00003943 if (const RecordType *RT = T->getAs<RecordType>()) {
3944 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003945 bool NeedZeroInitialization = true;
Richard Smith80ad52f2013-01-02 11:42:31 +00003946 if (!S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003947 // C++98:
3948 // -- if T is a class type (clause 9) with a user-declared constructor
3949 // (12.1), then the default constructor for T is called (and the
3950 // initialization is ill-formed if T has no accessible default
3951 // constructor);
Richard Smith1d0c9a82012-02-14 21:14:13 +00003952 if (ClassDecl->hasUserDeclaredConstructor())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003953 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003954 } else {
3955 // C++11:
3956 // -- if T is a class type (clause 9) with either no default constructor
3957 // (12.1 [class.ctor]) or a default constructor that is user-provided
3958 // or deleted, then the object is default-initialized;
3959 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
3960 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003961 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003962 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003963
Richard Smith1d0c9a82012-02-14 21:14:13 +00003964 // -- if T is a (possibly cv-qualified) non-union class type without a
3965 // user-provided or deleted default constructor, then the object is
3966 // zero-initialized and, if T has a non-trivial default constructor,
3967 // default-initialized;
Richard Smith6678a052012-10-18 00:44:17 +00003968 // The 'non-union' here was removed by DR1502. The 'non-trivial default
3969 // constructor' part was removed by DR1507.
Richard Smithf4bb8d02012-07-05 08:39:21 +00003970 if (NeedZeroInitialization)
3971 Sequence.AddZeroInitializationStep(Entity.getType());
3972
Richard Smithd5bc8672012-12-08 02:01:17 +00003973 // C++03:
3974 // -- if T is a non-union class type without a user-declared constructor,
3975 // then every non-static data member and base class component of T is
3976 // value-initialized;
3977 // [...] A program that calls for [...] value-initialization of an
3978 // entity of reference type is ill-formed.
3979 //
3980 // C++11 doesn't need this handling, because value-initialization does not
3981 // occur recursively there, and the implicit default constructor is
3982 // defined as deleted in the problematic cases.
Richard Smith80ad52f2013-01-02 11:42:31 +00003983 if (!S.getLangOpts().CPlusPlus11 &&
Richard Smithd5bc8672012-12-08 02:01:17 +00003984 ClassDecl->hasUninitializedReferenceMember()) {
3985 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
3986 return;
3987 }
3988
Richard Smithf4bb8d02012-07-05 08:39:21 +00003989 // If this is list-value-initialization, pass the empty init list on when
3990 // building the constructor call. This affects the semantics of a few
3991 // things (such as whether an explicit default constructor can be called).
3992 Expr *InitListAsExpr = InitList;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003993 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003994 bool InitListSyntax = InitList;
3995
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003996 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
3997 InitListSyntax);
Douglas Gregor71d17402009-12-15 00:01:57 +00003998 }
3999 }
4000
Douglas Gregord6542d82009-12-22 15:35:07 +00004001 Sequence.AddZeroInitializationStep(Entity.getType());
Douglas Gregor71d17402009-12-15 00:01:57 +00004002}
4003
Douglas Gregor99a2e602009-12-16 01:38:02 +00004004/// \brief Attempt default initialization (C++ [dcl.init]p6).
4005static void TryDefaultInitialization(Sema &S,
4006 const InitializedEntity &Entity,
4007 const InitializationKind &Kind,
4008 InitializationSequence &Sequence) {
4009 assert(Kind.getKind() == InitializationKind::IK_Default);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004010
Douglas Gregor99a2e602009-12-16 01:38:02 +00004011 // C++ [dcl.init]p6:
4012 // To default-initialize an object of type T means:
4013 // - if T is an array type, each element is default-initialized;
John McCallf85e1932011-06-15 23:02:42 +00004014 QualType DestType = S.Context.getBaseElementType(Entity.getType());
4015
Douglas Gregor99a2e602009-12-16 01:38:02 +00004016 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4017 // constructor for T is called (and the initialization is ill-formed if
4018 // T has no accessible default constructor);
David Blaikie4e4d0842012-03-11 07:00:24 +00004019 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00004020 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
Chandler Carruth4e6fbce2010-08-23 07:55:51 +00004021 return;
Douglas Gregor99a2e602009-12-16 01:38:02 +00004022 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004023
Douglas Gregor99a2e602009-12-16 01:38:02 +00004024 // - otherwise, no initialization is performed.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004025
Douglas Gregor99a2e602009-12-16 01:38:02 +00004026 // If a program calls for the default initialization of an object of
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004027 // a const-qualified type T, T shall be a class type with a user-provided
Douglas Gregor99a2e602009-12-16 01:38:02 +00004028 // default constructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00004029 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
Douglas Gregor99a2e602009-12-16 01:38:02 +00004030 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
John McCallf85e1932011-06-15 23:02:42 +00004031 return;
4032 }
4033
4034 // If the destination type has a lifetime property, zero-initialize it.
4035 if (DestType.getQualifiers().hasObjCLifetime()) {
4036 Sequence.AddZeroInitializationStep(Entity.getType());
4037 return;
4038 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00004039}
4040
Douglas Gregor20093b42009-12-09 23:02:17 +00004041/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4042/// which enumerates all conversion functions and performs overload resolution
4043/// to select the best.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004044static void TryUserDefinedConversion(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00004045 const InitializedEntity &Entity,
4046 const InitializationKind &Kind,
4047 Expr *Initializer,
Richard Smith13b228d2013-09-21 21:19:19 +00004048 InitializationSequence &Sequence,
4049 bool TopLevelOfInitList) {
Douglas Gregord6542d82009-12-22 15:35:07 +00004050 QualType DestType = Entity.getType();
Douglas Gregor4a520a22009-12-14 17:27:33 +00004051 assert(!DestType->isReferenceType() && "References are handled elsewhere");
4052 QualType SourceType = Initializer->getType();
4053 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4054 "Must have a class type to perform a user-defined conversion");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004055
Douglas Gregor4a520a22009-12-14 17:27:33 +00004056 // Build the candidate set directly in the initialization sequence
4057 // structure, so that it will persist if we fail.
4058 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4059 CandidateSet.clear();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004060
Douglas Gregor4a520a22009-12-14 17:27:33 +00004061 // Determine whether we are allowed to call explicit constructors or
4062 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00004063 bool AllowExplicit = Kind.AllowExplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004064
Douglas Gregor4a520a22009-12-14 17:27:33 +00004065 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4066 // The type we're converting to is a class type. Enumerate its constructors
4067 // to see if there is a suitable conversion.
4068 CXXRecordDecl *DestRecordDecl
4069 = cast<CXXRecordDecl>(DestRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004070
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004071 // Try to complete the type we're converting to.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004072 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004073 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004074 // The container holding the constructors can under certain conditions
4075 // be changed while iterating. To be safe we copy the lookup results
4076 // to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004077 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00004078 for (SmallVectorImpl<NamedDecl *>::iterator
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004079 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004080 Con != ConEnd; ++Con) {
4081 NamedDecl *D = *Con;
4082 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004083
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004084 // Find the constructor (which may be a template).
4085 CXXConstructorDecl *Constructor = 0;
4086 FunctionTemplateDecl *ConstructorTmpl
4087 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004088 if (ConstructorTmpl)
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004089 Constructor = cast<CXXConstructorDecl>(
4090 ConstructorTmpl->getTemplatedDecl());
Douglas Gregor4712c022010-07-01 03:43:00 +00004091 else
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004092 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004093
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004094 if (!Constructor->isInvalidDecl() &&
4095 Constructor->isConvertingConstructor(AllowExplicit)) {
4096 if (ConstructorTmpl)
4097 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4098 /*ExplicitArgs*/ 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004099 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004100 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004101 else
4102 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004103 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004104 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004105 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004106 }
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004107 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004108 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004109
4110 SourceLocation DeclLoc = Initializer->getLocStart();
4111
Douglas Gregor4a520a22009-12-14 17:27:33 +00004112 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4113 // The type we're converting from is a class type, enumerate its conversion
4114 // functions.
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004115
Eli Friedman33c2da92009-12-20 22:12:03 +00004116 // We can only enumerate the conversion functions for a complete type; if
4117 // the type isn't complete, simply skip this step.
4118 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4119 CXXRecordDecl *SourceRecordDecl
4120 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004121
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00004122 std::pair<CXXRecordDecl::conversion_iterator,
4123 CXXRecordDecl::conversion_iterator>
4124 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
4125 for (CXXRecordDecl::conversion_iterator
4126 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Eli Friedman33c2da92009-12-20 22:12:03 +00004127 NamedDecl *D = *I;
4128 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4129 if (isa<UsingShadowDecl>(D))
4130 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004131
Eli Friedman33c2da92009-12-20 22:12:03 +00004132 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4133 CXXConversionDecl *Conv;
Douglas Gregor4a520a22009-12-14 17:27:33 +00004134 if (ConvTemplate)
Eli Friedman33c2da92009-12-20 22:12:03 +00004135 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
Douglas Gregor4a520a22009-12-14 17:27:33 +00004136 else
John McCall32daa422010-03-31 01:36:47 +00004137 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004138
Eli Friedman33c2da92009-12-20 22:12:03 +00004139 if (AllowExplicit || !Conv->isExplicit()) {
4140 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00004141 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00004142 ActingDC, Initializer, DestType,
Stephen Hines651f13c2014-04-23 16:59:28 -07004143 CandidateSet, AllowExplicit);
Eli Friedman33c2da92009-12-20 22:12:03 +00004144 else
John McCall9aa472c2010-03-19 07:35:19 +00004145 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Stephen Hines651f13c2014-04-23 16:59:28 -07004146 Initializer, DestType, CandidateSet,
4147 AllowExplicit);
Eli Friedman33c2da92009-12-20 22:12:03 +00004148 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004149 }
4150 }
4151 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004152
4153 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004154 OverloadCandidateSet::iterator Best;
John McCall1d318332010-01-12 00:44:57 +00004155 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004156 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
Douglas Gregor4a520a22009-12-14 17:27:33 +00004157 Sequence.SetOverloadFailure(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004158 InitializationSequence::FK_UserConversionOverloadFailed,
Douglas Gregor4a520a22009-12-14 17:27:33 +00004159 Result);
4160 return;
4161 }
John McCall1d318332010-01-12 00:44:57 +00004162
Douglas Gregor4a520a22009-12-14 17:27:33 +00004163 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00004164 Function->setReferenced();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004165 bool HadMultipleCandidates = (CandidateSet.size() > 1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004166
Douglas Gregor4a520a22009-12-14 17:27:33 +00004167 if (isa<CXXConstructorDecl>(Function)) {
4168 // Add the user-defined conversion step. Any cv-qualification conversion is
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004169 // subsumed by the initialization. Per DR5, the created temporary is of the
4170 // cv-unqualified type of the destination.
4171 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4172 DestType.getUnqualifiedType(),
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004173 HadMultipleCandidates);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004174 return;
4175 }
4176
4177 // Add the user-defined conversion step that calls the conversion function.
Douglas Gregor5291c3c2010-07-13 08:18:22 +00004178 QualType ConvType = Function->getCallResultType();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004179 if (ConvType->getAs<RecordType>()) {
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004180 // If we're converting to a class type, there may be an copy of
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004181 // the resulting temporary object (possible to create an object of
4182 // a base class type). That copy is not a separate conversion, so
4183 // we just make a note of the actual destination type (possibly a
4184 // base class of the type returned by the conversion function) and
4185 // let the user-defined conversion step handle the conversion.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004186 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4187 HadMultipleCandidates);
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004188 return;
4189 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004190
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004191 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4192 HadMultipleCandidates);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004193
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004194 // If the conversion following the call to the conversion function
4195 // is interesting, add it as a separate step.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004196 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4197 Best->FinalConversion.Third) {
4198 ImplicitConversionSequence ICS;
John McCall1d318332010-01-12 00:44:57 +00004199 ICS.setStandard();
Douglas Gregor4a520a22009-12-14 17:27:33 +00004200 ICS.Standard = Best->FinalConversion;
Richard Smith13b228d2013-09-21 21:19:19 +00004201 Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004202 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004203}
4204
Richard Smith87c29322013-06-20 02:18:31 +00004205/// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4206/// a function with a pointer return type contains a 'return false;' statement.
4207/// In C++11, 'false' is not a null pointer, so this breaks the build of any
4208/// code using that header.
4209///
4210/// Work around this by treating 'return false;' as zero-initializing the result
4211/// if it's used in a pointer-returning function in a system header.
4212static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4213 const InitializedEntity &Entity,
4214 const Expr *Init) {
4215 return S.getLangOpts().CPlusPlus11 &&
4216 Entity.getKind() == InitializedEntity::EK_Result &&
4217 Entity.getType()->isPointerType() &&
4218 isa<CXXBoolLiteralExpr>(Init) &&
4219 !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4220 S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4221}
4222
John McCallf85e1932011-06-15 23:02:42 +00004223/// The non-zero enum values here are indexes into diagnostic alternatives.
4224enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4225
4226/// Determines whether this expression is an acceptable ICR source.
John McCallc03fa492011-06-27 23:59:58 +00004227static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004228 bool isAddressOf, bool &isWeakAccess) {
John McCallf85e1932011-06-15 23:02:42 +00004229 // Skip parens.
4230 e = e->IgnoreParens();
4231
4232 // Skip address-of nodes.
4233 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4234 if (op->getOpcode() == UO_AddrOf)
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004235 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4236 isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004237
4238 // Skip certain casts.
John McCallc03fa492011-06-27 23:59:58 +00004239 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4240 switch (ce->getCastKind()) {
John McCallf85e1932011-06-15 23:02:42 +00004241 case CK_Dependent:
4242 case CK_BitCast:
4243 case CK_LValueBitCast:
John McCallf85e1932011-06-15 23:02:42 +00004244 case CK_NoOp:
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004245 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004246
4247 case CK_ArrayToPointerDecay:
4248 return IIK_nonscalar;
4249
4250 case CK_NullToPointer:
4251 return IIK_okay;
4252
4253 default:
4254 break;
4255 }
4256
4257 // If we have a declaration reference, it had better be a local variable.
John McCallf4b88a42012-03-10 09:33:50 +00004258 } else if (isa<DeclRefExpr>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004259 // set isWeakAccess to true, to mean that there will be an implicit
4260 // load which requires a cleanup.
4261 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4262 isWeakAccess = true;
4263
John McCallc03fa492011-06-27 23:59:58 +00004264 if (!isAddressOf) return IIK_nonlocal;
4265
John McCallf4b88a42012-03-10 09:33:50 +00004266 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4267 if (!var) return IIK_nonlocal;
John McCallc03fa492011-06-27 23:59:58 +00004268
4269 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
John McCallf85e1932011-06-15 23:02:42 +00004270
4271 // If we have a conditional operator, check both sides.
4272 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004273 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4274 isWeakAccess))
John McCallf85e1932011-06-15 23:02:42 +00004275 return iik;
4276
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004277 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004278
4279 // These are never scalar.
4280 } else if (isa<ArraySubscriptExpr>(e)) {
4281 return IIK_nonscalar;
4282
4283 // Otherwise, it needs to be a null pointer constant.
4284 } else {
4285 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4286 ? IIK_okay : IIK_nonlocal);
4287 }
4288
4289 return IIK_nonlocal;
4290}
4291
4292/// Check whether the given expression is a valid operand for an
4293/// indirect copy/restore.
4294static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4295 assert(src->isRValue());
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004296 bool isWeakAccess = false;
4297 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4298 // If isWeakAccess to true, there will be an implicit
4299 // load which requires a cleanup.
4300 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4301 S.ExprNeedsCleanups = true;
4302
John McCallf85e1932011-06-15 23:02:42 +00004303 if (iik == IIK_okay) return;
4304
4305 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4306 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4307 << src->getSourceRange();
4308}
4309
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004310/// \brief Determine whether we have compatible array types for the
4311/// purposes of GNU by-copy array initialization.
4312static bool hasCompatibleArrayTypes(ASTContext &Context,
4313 const ArrayType *Dest,
4314 const ArrayType *Source) {
4315 // If the source and destination array types are equivalent, we're
4316 // done.
4317 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4318 return true;
4319
4320 // Make sure that the element types are the same.
4321 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4322 return false;
4323
4324 // The only mismatch we allow is when the destination is an
4325 // incomplete array type and the source is a constant array type.
4326 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4327}
4328
John McCallf85e1932011-06-15 23:02:42 +00004329static bool tryObjCWritebackConversion(Sema &S,
4330 InitializationSequence &Sequence,
4331 const InitializedEntity &Entity,
4332 Expr *Initializer) {
4333 bool ArrayDecay = false;
4334 QualType ArgType = Initializer->getType();
4335 QualType ArgPointee;
4336 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4337 ArrayDecay = true;
4338 ArgPointee = ArgArrayType->getElementType();
4339 ArgType = S.Context.getPointerType(ArgPointee);
4340 }
4341
4342 // Handle write-back conversion.
4343 QualType ConvertedArgType;
4344 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4345 ConvertedArgType))
4346 return false;
4347
4348 // We should copy unless we're passing to an argument explicitly
4349 // marked 'out'.
4350 bool ShouldCopy = true;
4351 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4352 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4353
4354 // Do we need an lvalue conversion?
4355 if (ArrayDecay || Initializer->isGLValue()) {
4356 ImplicitConversionSequence ICS;
4357 ICS.setStandard();
4358 ICS.Standard.setAsIdentityConversion();
4359
4360 QualType ResultType;
4361 if (ArrayDecay) {
4362 ICS.Standard.First = ICK_Array_To_Pointer;
4363 ResultType = S.Context.getPointerType(ArgPointee);
4364 } else {
4365 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4366 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4367 }
4368
4369 Sequence.AddConversionSequenceStep(ICS, ResultType);
4370 }
4371
4372 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4373 return true;
4374}
4375
Guy Benyei21f18c42013-02-07 10:55:47 +00004376static bool TryOCLSamplerInitialization(Sema &S,
4377 InitializationSequence &Sequence,
4378 QualType DestType,
4379 Expr *Initializer) {
4380 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4381 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4382 return false;
4383
4384 Sequence.AddOCLSamplerInitStep(DestType);
4385 return true;
4386}
4387
Guy Benyeie6b9d802013-01-20 12:31:11 +00004388//
4389// OpenCL 1.2 spec, s6.12.10
4390//
4391// The event argument can also be used to associate the
4392// async_work_group_copy with a previous async copy allowing
4393// an event to be shared by multiple async copies; otherwise
4394// event should be zero.
4395//
4396static bool TryOCLZeroEventInitialization(Sema &S,
4397 InitializationSequence &Sequence,
4398 QualType DestType,
4399 Expr *Initializer) {
4400 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4401 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4402 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4403 return false;
4404
4405 Sequence.AddOCLZeroEventStep(DestType);
4406 return true;
4407}
4408
Douglas Gregor20093b42009-12-09 23:02:17 +00004409InitializationSequence::InitializationSequence(Sema &S,
4410 const InitializedEntity &Entity,
4411 const InitializationKind &Kind,
Richard Smith13b228d2013-09-21 21:19:19 +00004412 MultiExprArg Args,
4413 bool TopLevelOfInitList)
John McCall5769d612010-02-08 23:07:23 +00004414 : FailedCandidateSet(Kind.getLocation()) {
Richard Smithb390e492013-09-21 21:55:46 +00004415 InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4416}
4417
4418void InitializationSequence::InitializeFrom(Sema &S,
4419 const InitializedEntity &Entity,
4420 const InitializationKind &Kind,
4421 MultiExprArg Args,
4422 bool TopLevelOfInitList) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004423 ASTContext &Context = S.Context;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004424
John McCall76da55d2013-04-16 07:28:30 +00004425 // Eliminate non-overload placeholder types in the arguments. We
4426 // need to do this before checking whether types are dependent
4427 // because lowering a pseudo-object expression might well give us
4428 // something of dependent type.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004429 for (unsigned I = 0, E = Args.size(); I != E; ++I)
John McCall76da55d2013-04-16 07:28:30 +00004430 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4431 // FIXME: should we be doing this here?
4432 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4433 if (result.isInvalid()) {
4434 SetFailed(FK_PlaceholderType);
4435 return;
4436 }
4437 Args[I] = result.take();
4438 }
4439
Douglas Gregor20093b42009-12-09 23:02:17 +00004440 // C++0x [dcl.init]p16:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004441 // The semantics of initializers are as follows. The destination type is
4442 // the type of the object or reference being initialized and the source
Douglas Gregor20093b42009-12-09 23:02:17 +00004443 // type is the type of the initializer expression. The source type is not
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004444 // defined when the initializer is a braced-init-list or when it is a
Douglas Gregor20093b42009-12-09 23:02:17 +00004445 // parenthesized list of expressions.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004446 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00004447
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004448 if (DestType->isDependentType() ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004449 Expr::hasAnyTypeDependentArguments(Args)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004450 SequenceKind = DependentSequence;
4451 return;
4452 }
4453
Sebastian Redl7491c492011-06-05 13:59:11 +00004454 // Almost everything is a normal sequence.
4455 setSequenceKind(NormalSequence);
4456
Douglas Gregor20093b42009-12-09 23:02:17 +00004457 QualType SourceType;
4458 Expr *Initializer = 0;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004459 if (Args.size() == 1) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004460 Initializer = Args[0];
Stephen Hines651f13c2014-04-23 16:59:28 -07004461 if (S.getLangOpts().ObjC1) {
4462 if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
4463 DestType, Initializer->getType(),
4464 Initializer) ||
4465 S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
4466 Args[0] = Initializer;
4467
4468 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004469 if (!isa<InitListExpr>(Initializer))
4470 SourceType = Initializer->getType();
4471 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004472
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00004473 // - If the initializer is a (non-parenthesized) braced-init-list, the
4474 // object is list-initialized (8.5.4).
4475 if (Kind.getKind() != InitializationKind::IK_Direct) {
4476 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4477 TryListInitialization(S, Entity, Kind, InitList, *this);
4478 return;
4479 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004480 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004481
Douglas Gregor20093b42009-12-09 23:02:17 +00004482 // - If the destination type is a reference type, see 8.5.3.
4483 if (DestType->isReferenceType()) {
4484 // C++0x [dcl.init.ref]p1:
4485 // A variable declared to be a T& or T&&, that is, "reference to type T"
4486 // (8.3.2), shall be initialized by an object, or function, of type T or
4487 // by an object that can be converted into a T.
4488 // (Therefore, multiple arguments are not permitted.)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004489 if (Args.size() != 1)
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004490 SetFailed(FK_TooManyInitsForReference);
Douglas Gregor20093b42009-12-09 23:02:17 +00004491 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004492 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004493 return;
4494 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004495
Douglas Gregor20093b42009-12-09 23:02:17 +00004496 // - If the initializer is (), the object is value-initialized.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004497 if (Kind.getKind() == InitializationKind::IK_Value ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004498 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004499 TryValueInitialization(S, Entity, Kind, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004500 return;
4501 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004502
Douglas Gregor99a2e602009-12-16 01:38:02 +00004503 // Handle default initialization.
Nick Lewycky7663f392010-11-20 01:29:55 +00004504 if (Kind.getKind() == InitializationKind::IK_Default) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004505 TryDefaultInitialization(S, Entity, Kind, *this);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004506 return;
4507 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004508
John McCallce6c9b72011-02-21 07:22:22 +00004509 // - If the destination type is an array of characters, an array of
4510 // char16_t, an array of char32_t, or an array of wchar_t, and the
4511 // initializer is a string literal, see 8.5.2.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004512 // - Otherwise, if the destination type is an array, the program is
Douglas Gregor20093b42009-12-09 23:02:17 +00004513 // ill-formed.
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004514 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
John McCall73076432012-01-05 00:13:19 +00004515 if (Initializer && isa<VariableArrayType>(DestAT)) {
4516 SetFailed(FK_VariableLengthArrayHasInitializer);
4517 return;
4518 }
4519
Hans Wennborg0ff50742013-05-15 11:03:04 +00004520 if (Initializer) {
4521 switch (IsStringInit(Initializer, DestAT, Context)) {
4522 case SIF_None:
4523 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4524 return;
4525 case SIF_NarrowStringIntoWideChar:
4526 SetFailed(FK_NarrowStringIntoWideCharArray);
4527 return;
4528 case SIF_WideStringIntoChar:
4529 SetFailed(FK_WideStringIntoCharArray);
4530 return;
4531 case SIF_IncompatWideStringIntoWideChar:
4532 SetFailed(FK_IncompatWideStringIntoWideChar);
4533 return;
4534 case SIF_Other:
4535 break;
4536 }
John McCallce6c9b72011-02-21 07:22:22 +00004537 }
4538
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004539 // Note: as an GNU C extension, we allow initialization of an
4540 // array from a compound literal that creates an array of the same
4541 // type, so long as the initializer has no side effects.
David Blaikie4e4d0842012-03-11 07:00:24 +00004542 if (!S.getLangOpts().CPlusPlus && Initializer &&
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004543 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4544 Initializer->getType()->isArrayType()) {
4545 const ArrayType *SourceAT
4546 = Context.getAsArrayType(Initializer->getType());
4547 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004548 SetFailed(FK_ArrayTypeMismatch);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004549 else if (Initializer->HasSideEffects(S.Context))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004550 SetFailed(FK_NonConstantArrayInit);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004551 else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004552 AddArrayInitStep(DestType);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004553 }
Richard Smith0f163e92012-02-15 22:38:09 +00004554 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00004555 // Note: as a GNU C++ extension, we allow list-initialization of a
4556 // class member of array type from a parenthesized initializer list.
David Blaikie4e4d0842012-03-11 07:00:24 +00004557 else if (S.getLangOpts().CPlusPlus &&
Richard Smith0f163e92012-02-15 22:38:09 +00004558 Entity.getKind() == InitializedEntity::EK_Member &&
4559 Initializer && isa<InitListExpr>(Initializer)) {
4560 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4561 *this);
4562 AddParenthesizedArrayInitStep(DestType);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004563 } else if (DestAT->getElementType()->isCharType())
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004564 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004565 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4566 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
Douglas Gregor20093b42009-12-09 23:02:17 +00004567 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004568 SetFailed(FK_ArrayNeedsInitList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004569
Douglas Gregor20093b42009-12-09 23:02:17 +00004570 return;
4571 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004572
John McCallf85e1932011-06-15 23:02:42 +00004573 // Determine whether we should consider writeback conversions for
4574 // Objective-C ARC.
David Blaikie4e4d0842012-03-11 07:00:24 +00004575 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004576 Entity.isParameterKind();
John McCallf85e1932011-06-15 23:02:42 +00004577
4578 // We're at the end of the line for C: it's either a write-back conversion
4579 // or it's a C assignment. There's no need to check anything else.
David Blaikie4e4d0842012-03-11 07:00:24 +00004580 if (!S.getLangOpts().CPlusPlus) {
John McCallf85e1932011-06-15 23:02:42 +00004581 // If allowed, check whether this is an Objective-C writeback conversion.
4582 if (allowObjCWritebackConversion &&
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004583 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
John McCallf85e1932011-06-15 23:02:42 +00004584 return;
4585 }
Guy Benyei21f18c42013-02-07 10:55:47 +00004586
4587 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4588 return;
Guy Benyeie6b9d802013-01-20 12:31:11 +00004589
4590 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4591 return;
4592
John McCallf85e1932011-06-15 23:02:42 +00004593 // Handle initialization in C
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004594 AddCAssignmentStep(DestType);
4595 MaybeProduceObjCObject(S, *this, Entity);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004596 return;
4597 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004598
David Blaikie4e4d0842012-03-11 07:00:24 +00004599 assert(S.getLangOpts().CPlusPlus);
John McCallf85e1932011-06-15 23:02:42 +00004600
Douglas Gregor20093b42009-12-09 23:02:17 +00004601 // - If the destination type is a (possibly cv-qualified) class type:
4602 if (DestType->isRecordType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004603 // - If the initialization is direct-initialization, or if it is
4604 // copy-initialization where the cv-unqualified version of the
4605 // source type is the same class as, or a derived class of, the
Douglas Gregor20093b42009-12-09 23:02:17 +00004606 // class of the destination, constructors are considered. [...]
4607 if (Kind.getKind() == InitializationKind::IK_Direct ||
4608 (Kind.getKind() == InitializationKind::IK_Copy &&
4609 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4610 S.IsDerivedFrom(SourceType, DestType))))
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004611 TryConstructorInitialization(S, Entity, Kind, Args,
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004612 Entity.getType(), *this);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004613 // - Otherwise (i.e., for the remaining copy-initialization cases),
Douglas Gregor20093b42009-12-09 23:02:17 +00004614 // user-defined conversion sequences that can convert from the source
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004615 // type to the destination type or (when a conversion function is
Douglas Gregor20093b42009-12-09 23:02:17 +00004616 // used) to a derived class thereof are enumerated as described in
4617 // 13.3.1.4, and the best one is chosen through overload resolution
4618 // (13.3).
4619 else
Richard Smith13b228d2013-09-21 21:19:19 +00004620 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4621 TopLevelOfInitList);
Douglas Gregor20093b42009-12-09 23:02:17 +00004622 return;
4623 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004624
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004625 if (Args.size() > 1) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004626 SetFailed(FK_TooManyInitsForScalar);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004627 return;
4628 }
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004629 assert(Args.size() == 1 && "Zero-argument case handled above");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004630
4631 // - Otherwise, if the source type is a (possibly cv-qualified) class
Douglas Gregor20093b42009-12-09 23:02:17 +00004632 // type, conversion functions are considered.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004633 if (!SourceType.isNull() && SourceType->isRecordType()) {
Richard Smith13b228d2013-09-21 21:19:19 +00004634 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4635 TopLevelOfInitList);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004636 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00004637 return;
4638 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004639
Douglas Gregor20093b42009-12-09 23:02:17 +00004640 // - Otherwise, the initial value of the object being initialized is the
Douglas Gregor4a520a22009-12-14 17:27:33 +00004641 // (possibly converted) value of the initializer expression. Standard
Douglas Gregor20093b42009-12-09 23:02:17 +00004642 // conversions (Clause 4) will be used, if necessary, to convert the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004643 // initializer expression to the cv-unqualified version of the
Douglas Gregor20093b42009-12-09 23:02:17 +00004644 // destination type; no user-defined conversions are considered.
John McCallf85e1932011-06-15 23:02:42 +00004645
4646 ImplicitConversionSequence ICS
4647 = S.TryImplicitConversion(Initializer, Entity.getType(),
4648 /*SuppressUserConversions*/true,
John McCall369371c2010-06-04 02:29:22 +00004649 /*AllowExplicitConversions*/ false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00004650 /*InOverloadResolution*/ false,
John McCallf85e1932011-06-15 23:02:42 +00004651 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4652 allowObjCWritebackConversion);
4653
4654 if (ICS.isStandard() &&
4655 ICS.Standard.Second == ICK_Writeback_Conversion) {
4656 // Objective-C ARC writeback conversion.
4657
4658 // We should copy unless we're passing to an argument explicitly
4659 // marked 'out'.
4660 bool ShouldCopy = true;
4661 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4662 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4663
4664 // If there was an lvalue adjustment, add it as a separate conversion.
4665 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4666 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4667 ImplicitConversionSequence LvalueICS;
4668 LvalueICS.setStandard();
4669 LvalueICS.Standard.setAsIdentityConversion();
4670 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4671 LvalueICS.Standard.First = ICS.Standard.First;
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004672 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
John McCallf85e1932011-06-15 23:02:42 +00004673 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004674
4675 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
John McCallf85e1932011-06-15 23:02:42 +00004676 } else if (ICS.isBad()) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004677 DeclAccessPair dap;
Richard Smith87c29322013-06-20 02:18:31 +00004678 if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
4679 AddZeroInitializationStep(Entity.getType());
4680 } else if (Initializer->getType() == Context.OverloadTy &&
4681 !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
4682 false, dap))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004683 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor8e960432010-11-08 03:40:48 +00004684 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004685 SetFailed(InitializationSequence::FK_ConversionFailed);
John McCallf85e1932011-06-15 23:02:42 +00004686 } else {
Richard Smith13b228d2013-09-21 21:19:19 +00004687 AddConversionSequenceStep(ICS, Entity.getType(), TopLevelOfInitList);
John McCall856d3792011-06-16 23:24:51 +00004688
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004689 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor8e960432010-11-08 03:40:48 +00004690 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004691}
4692
4693InitializationSequence::~InitializationSequence() {
Chris Lattner5f9e2722011-07-23 10:55:15 +00004694 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
Douglas Gregor20093b42009-12-09 23:02:17 +00004695 StepEnd = Steps.end();
4696 Step != StepEnd; ++Step)
4697 Step->Destroy();
4698}
4699
4700//===----------------------------------------------------------------------===//
4701// Perform initialization
4702//===----------------------------------------------------------------------===//
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004703static Sema::AssignmentAction
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00004704getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004705 switch(Entity.getKind()) {
4706 case InitializedEntity::EK_Variable:
4707 case InitializedEntity::EK_New:
Douglas Gregora3998bd2010-12-02 21:47:04 +00004708 case InitializedEntity::EK_Exception:
4709 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004710 case InitializedEntity::EK_Delegating:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004711 return Sema::AA_Initializing;
4712
4713 case InitializedEntity::EK_Parameter:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004714 if (Entity.getDecl() &&
Douglas Gregor688fc9b2010-04-21 23:24:10 +00004715 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4716 return Sema::AA_Sending;
4717
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004718 return Sema::AA_Passing;
4719
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00004720 case InitializedEntity::EK_Parameter_CF_Audited:
4721 if (Entity.getDecl() &&
4722 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4723 return Sema::AA_Sending;
4724
4725 return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
4726
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004727 case InitializedEntity::EK_Result:
4728 return Sema::AA_Returning;
4729
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004730 case InitializedEntity::EK_Temporary:
Fariborz Jahanianf5200d62013-07-11 19:13:34 +00004731 case InitializedEntity::EK_RelatedResult:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004732 // FIXME: Can we tell apart casting vs. converting?
4733 return Sema::AA_Casting;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004734
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004735 case InitializedEntity::EK_Member:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004736 case InitializedEntity::EK_ArrayElement:
4737 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004738 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004739 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004740 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004741 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004742 return Sema::AA_Initializing;
4743 }
4744
David Blaikie7530c032012-01-17 06:56:22 +00004745 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004746}
4747
Richard Smith774d8b42013-01-08 00:08:23 +00004748/// \brief Whether we should bind a created object as a temporary when
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004749/// initializing the given entity.
Douglas Gregor2f599792010-04-02 18:24:57 +00004750static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004751 switch (Entity.getKind()) {
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004752 case InitializedEntity::EK_ArrayElement:
4753 case InitializedEntity::EK_Member:
Douglas Gregor2f599792010-04-02 18:24:57 +00004754 case InitializedEntity::EK_Result:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004755 case InitializedEntity::EK_New:
4756 case InitializedEntity::EK_Variable:
4757 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004758 case InitializedEntity::EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004759 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004760 case InitializedEntity::EK_ComplexElement:
Anders Carlssona508b7d2010-02-06 23:23:06 +00004761 case InitializedEntity::EK_Exception:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004762 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004763 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004764 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004765 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004766
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004767 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004768 case InitializedEntity::EK_Parameter_CF_Audited:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004769 case InitializedEntity::EK_Temporary:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004770 case InitializedEntity::EK_RelatedResult:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004771 return true;
4772 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004773
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004774 llvm_unreachable("missed an InitializedEntity kind?");
4775}
4776
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004777/// \brief Whether the given entity, when initialized with an object
4778/// created for that initialization, requires destruction.
4779static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4780 switch (Entity.getKind()) {
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004781 case InitializedEntity::EK_Result:
4782 case InitializedEntity::EK_New:
4783 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004784 case InitializedEntity::EK_Delegating:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004785 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004786 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004787 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004788 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004789 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004790
Richard Smith774d8b42013-01-08 00:08:23 +00004791 case InitializedEntity::EK_Member:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004792 case InitializedEntity::EK_Variable:
4793 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004794 case InitializedEntity::EK_Parameter_CF_Audited:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004795 case InitializedEntity::EK_Temporary:
4796 case InitializedEntity::EK_ArrayElement:
4797 case InitializedEntity::EK_Exception:
Jordan Rose2624b812013-05-06 16:48:12 +00004798 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004799 case InitializedEntity::EK_RelatedResult:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004800 return true;
4801 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004802
4803 llvm_unreachable("missed an InitializedEntity kind?");
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004804}
4805
Richard Smith83da2e72011-10-19 16:55:56 +00004806/// \brief Look for copy and move constructors and constructor templates, for
4807/// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4808static void LookupCopyAndMoveConstructors(Sema &S,
4809 OverloadCandidateSet &CandidateSet,
4810 CXXRecordDecl *Class,
4811 Expr *CurInitExpr) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004812 DeclContext::lookup_result R = S.LookupConstructors(Class);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004813 // The container holding the constructors can under certain conditions
4814 // be changed while iterating (e.g. because of deserialization).
4815 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004816 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00004817 for (SmallVectorImpl<NamedDecl *>::iterator
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004818 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4819 NamedDecl *D = *CI;
Richard Smith83da2e72011-10-19 16:55:56 +00004820 CXXConstructorDecl *Constructor = 0;
4821
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004822 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
Richard Smith83da2e72011-10-19 16:55:56 +00004823 // Handle copy/moveconstructors, only.
4824 if (!Constructor || Constructor->isInvalidDecl() ||
4825 !Constructor->isCopyOrMoveConstructor() ||
4826 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4827 continue;
4828
4829 DeclAccessPair FoundDecl
4830 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4831 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004832 CurInitExpr, CandidateSet);
Richard Smith83da2e72011-10-19 16:55:56 +00004833 continue;
4834 }
4835
4836 // Handle constructor templates.
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004837 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
Richard Smith83da2e72011-10-19 16:55:56 +00004838 if (ConstructorTmpl->isInvalidDecl())
4839 continue;
4840
4841 Constructor = cast<CXXConstructorDecl>(
4842 ConstructorTmpl->getTemplatedDecl());
4843 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4844 continue;
4845
4846 // FIXME: Do we need to limit this to copy-constructor-like
4847 // candidates?
4848 DeclAccessPair FoundDecl
4849 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
4850 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004851 CurInitExpr, CandidateSet, true);
Richard Smith83da2e72011-10-19 16:55:56 +00004852 }
4853}
4854
4855/// \brief Get the location at which initialization diagnostics should appear.
4856static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4857 Expr *Initializer) {
4858 switch (Entity.getKind()) {
4859 case InitializedEntity::EK_Result:
4860 return Entity.getReturnLoc();
4861
4862 case InitializedEntity::EK_Exception:
4863 return Entity.getThrowLoc();
4864
4865 case InitializedEntity::EK_Variable:
4866 return Entity.getDecl()->getLocation();
4867
Douglas Gregor47736542012-02-15 16:57:26 +00004868 case InitializedEntity::EK_LambdaCapture:
4869 return Entity.getCaptureLoc();
4870
Richard Smith83da2e72011-10-19 16:55:56 +00004871 case InitializedEntity::EK_ArrayElement:
4872 case InitializedEntity::EK_Member:
4873 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004874 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith83da2e72011-10-19 16:55:56 +00004875 case InitializedEntity::EK_Temporary:
4876 case InitializedEntity::EK_New:
4877 case InitializedEntity::EK_Base:
4878 case InitializedEntity::EK_Delegating:
4879 case InitializedEntity::EK_VectorElement:
4880 case InitializedEntity::EK_ComplexElement:
4881 case InitializedEntity::EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00004882 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004883 case InitializedEntity::EK_RelatedResult:
Richard Smith83da2e72011-10-19 16:55:56 +00004884 return Initializer->getLocStart();
4885 }
4886 llvm_unreachable("missed an InitializedEntity kind?");
4887}
4888
Douglas Gregor523d46a2010-04-18 07:40:54 +00004889/// \brief Make a (potentially elidable) temporary copy of the object
4890/// provided by the given initializer by calling the appropriate copy
4891/// constructor.
4892///
4893/// \param S The Sema object used for type-checking.
4894///
Abramo Bagnara63e7d252011-01-27 19:55:10 +00004895/// \param T The type of the temporary object, which must either be
Douglas Gregor523d46a2010-04-18 07:40:54 +00004896/// the type of the initializer expression or a superclass thereof.
4897///
James Dennett1dfbd922012-06-14 21:40:34 +00004898/// \param Entity The entity being initialized.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004899///
4900/// \param CurInit The initializer expression.
4901///
4902/// \param IsExtraneousCopy Whether this is an "extraneous" copy that
4903/// is permitted in C++03 (but not C++0x) when binding a reference to
4904/// an rvalue.
4905///
4906/// \returns An expression that copies the initializer expression into
4907/// a temporary object, or an error expression if a copy could not be
4908/// created.
John McCall60d7b3a2010-08-24 06:29:42 +00004909static ExprResult CopyObject(Sema &S,
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004910 QualType T,
4911 const InitializedEntity &Entity,
4912 ExprResult CurInit,
4913 bool IsExtraneousCopy) {
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004914 // Determine which class type we're copying to.
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004915 Expr *CurInitExpr = (Expr *)CurInit.get();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004916 CXXRecordDecl *Class = 0;
Douglas Gregor523d46a2010-04-18 07:40:54 +00004917 if (const RecordType *Record = T->getAs<RecordType>())
Douglas Gregor2f599792010-04-02 18:24:57 +00004918 Class = cast<CXXRecordDecl>(Record->getDecl());
4919 if (!Class)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004920 return CurInit;
Douglas Gregor2f599792010-04-02 18:24:57 +00004921
Douglas Gregorf5d8f462011-01-21 18:05:27 +00004922 // C++0x [class.copy]p32:
Douglas Gregor2f599792010-04-02 18:24:57 +00004923 // When certain criteria are met, an implementation is allowed to
4924 // omit the copy/move construction of a class object, even if the
4925 // copy/move constructor and/or destructor for the object have
4926 // side effects. [...]
4927 // - when a temporary class object that has not been bound to a
4928 // reference (12.2) would be copied/moved to a class object
4929 // with the same cv-unqualified type, the copy/move operation
4930 // can be omitted by constructing the temporary object
4931 // directly into the target of the omitted copy/move
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004932 //
Douglas Gregor2f599792010-04-02 18:24:57 +00004933 // Note that the other three bullets are handled elsewhere. Copy
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004934 // elision for return statements and throw expressions are handled as part
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004935 // of constructor initialization, while copy elision for exception handlers
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004936 // is handled by the run-time.
John McCall558d2ab2010-09-15 10:14:12 +00004937 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
Richard Smith83da2e72011-10-19 16:55:56 +00004938 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004939
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004940 // Make sure that the type we are copying is complete.
Douglas Gregord10099e2012-05-04 16:32:21 +00004941 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004942 return CurInit;
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004943
Douglas Gregorcc15f012011-01-21 19:38:21 +00004944 // Perform overload resolution using the class's copy/move constructors.
Richard Smith83da2e72011-10-19 16:55:56 +00004945 // Only consider constructors and constructor templates. Per
4946 // C++0x [dcl.init]p16, second bullet to class types, this initialization
4947 // is direct-initialization.
John McCall5769d612010-02-08 23:07:23 +00004948 OverloadCandidateSet CandidateSet(Loc);
Richard Smith83da2e72011-10-19 16:55:56 +00004949 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004950
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004951 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4952
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004953 OverloadCandidateSet::iterator Best;
Chandler Carruth25ca4212011-02-25 19:41:05 +00004954 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004955 case OR_Success:
4956 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004957
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004958 case OR_No_Viable_Function:
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004959 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
4960 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
4961 : diag::err_temp_copy_no_viable)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004962 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004963 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004964 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004965 if (!IsExtraneousCopy || S.isSFINAEContext())
John McCallf312b1e2010-08-26 23:41:50 +00004966 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004967 return CurInit;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004968
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004969 case OR_Ambiguous:
4970 S.Diag(Loc, diag::err_temp_copy_ambiguous)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004971 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004972 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004973 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
John McCallf312b1e2010-08-26 23:41:50 +00004974 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004975
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004976 case OR_Deleted:
4977 S.Diag(Loc, diag::err_temp_copy_deleted)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004978 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004979 << CurInitExpr->getSourceRange();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004980 S.NoteDeletedFunction(Best->Function);
John McCallf312b1e2010-08-26 23:41:50 +00004981 return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004982 }
4983
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004984 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00004985 SmallVector<Expr*, 8> ConstructorArgs;
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004986 CurInit.release(); // Ownership transferred into MultiExprArg, below.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004987
Anders Carlsson9a68a672010-04-21 18:47:17 +00004988 S.CheckConstructorAccess(Loc, Constructor, Entity,
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004989 Best->FoundDecl.getAccess(), IsExtraneousCopy);
Douglas Gregor523d46a2010-04-18 07:40:54 +00004990
4991 if (IsExtraneousCopy) {
4992 // If this is a totally extraneous copy for C++03 reference
4993 // binding purposes, just return the original initialization
Douglas Gregor2559a702010-04-18 07:57:34 +00004994 // expression. We don't generate an (elided) copy operation here
4995 // because doing so would require us to pass down a flag to avoid
4996 // infinite recursion, where each step adds another extraneous,
4997 // elidable copy.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004998
Douglas Gregor2559a702010-04-18 07:57:34 +00004999 // Instantiate the default arguments of any extra parameters in
5000 // the selected copy constructor, as if we were going to create a
5001 // proper call to the copy constructor.
5002 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5003 ParmVarDecl *Parm = Constructor->getParamDecl(I);
5004 if (S.RequireCompleteType(Loc, Parm->getType(),
Douglas Gregord10099e2012-05-04 16:32:21 +00005005 diag::err_call_incomplete_argument))
Douglas Gregor2559a702010-04-18 07:57:34 +00005006 break;
5007
5008 // Build the default argument expression; we don't actually care
5009 // if this succeeds or not, because this routine will complain
5010 // if there was a problem.
5011 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5012 }
5013
Douglas Gregor523d46a2010-04-18 07:40:54 +00005014 return S.Owned(CurInitExpr);
5015 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005016
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00005017 // Determine the arguments required to actually perform the
Douglas Gregor523d46a2010-04-18 07:40:54 +00005018 // constructor call (we might have derived-to-base conversions, or
5019 // the copy constructor may have default arguments).
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00005020 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005021 return ExprError();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00005022
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00005023 // Actually perform the constructor call.
5024 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005025 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005026 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005027 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005028 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005029 CXXConstructExpr::CK_Complete,
5030 SourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005031
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00005032 // If we're supposed to bind temporaries, do so.
5033 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5034 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005035 return CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005036}
Douglas Gregor20093b42009-12-09 23:02:17 +00005037
Richard Smith83da2e72011-10-19 16:55:56 +00005038/// \brief Check whether elidable copy construction for binding a reference to
5039/// a temporary would have succeeded if we were building in C++98 mode, for
5040/// -Wc++98-compat.
5041static void CheckCXX98CompatAccessibleCopy(Sema &S,
5042 const InitializedEntity &Entity,
5043 Expr *CurInitExpr) {
Richard Smith80ad52f2013-01-02 11:42:31 +00005044 assert(S.getLangOpts().CPlusPlus11);
Richard Smith83da2e72011-10-19 16:55:56 +00005045
5046 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5047 if (!Record)
5048 return;
5049
5050 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5051 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc)
5052 == DiagnosticsEngine::Ignored)
5053 return;
5054
5055 // Find constructors which would have been considered.
5056 OverloadCandidateSet CandidateSet(Loc);
5057 LookupCopyAndMoveConstructors(
5058 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5059
5060 // Perform overload resolution.
5061 OverloadCandidateSet::iterator Best;
5062 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5063
5064 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5065 << OR << (int)Entity.getKind() << CurInitExpr->getType()
5066 << CurInitExpr->getSourceRange();
5067
5068 switch (OR) {
5069 case OR_Success:
5070 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
John McCallb9abd8722012-04-07 03:04:20 +00005071 Entity, Best->FoundDecl.getAccess(), Diag);
Richard Smith83da2e72011-10-19 16:55:56 +00005072 // FIXME: Check default arguments as far as that's possible.
5073 break;
5074
5075 case OR_No_Viable_Function:
5076 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00005077 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00005078 break;
5079
5080 case OR_Ambiguous:
5081 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00005082 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00005083 break;
5084
5085 case OR_Deleted:
5086 S.Diag(Loc, Diag);
Richard Smith6c4c36c2012-03-30 20:53:28 +00005087 S.NoteDeletedFunction(Best->Function);
Richard Smith83da2e72011-10-19 16:55:56 +00005088 break;
5089 }
5090}
5091
Douglas Gregora41a8c52010-04-22 00:20:18 +00005092void InitializationSequence::PrintInitLocationNote(Sema &S,
5093 const InitializedEntity &Entity) {
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005094 if (Entity.isParameterKind() && Entity.getDecl()) {
Douglas Gregora41a8c52010-04-22 00:20:18 +00005095 if (Entity.getDecl()->getLocation().isInvalid())
5096 return;
5097
5098 if (Entity.getDecl()->getDeclName())
5099 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5100 << Entity.getDecl()->getDeclName();
5101 else
5102 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5103 }
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005104 else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5105 Entity.getMethodDecl())
5106 S.Diag(Entity.getMethodDecl()->getLocation(),
5107 diag::note_method_return_type_change)
5108 << Entity.getMethodDecl()->getDeclName();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005109}
5110
Sebastian Redl3b802322011-07-14 19:07:55 +00005111static bool isReferenceBinding(const InitializationSequence::Step &s) {
5112 return s.Kind == InitializationSequence::SK_BindReference ||
5113 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5114}
5115
Jordan Rose2624b812013-05-06 16:48:12 +00005116/// Returns true if the parameters describe a constructor initialization of
5117/// an explicit temporary object, e.g. "Point(x, y)".
5118static bool isExplicitTemporary(const InitializedEntity &Entity,
5119 const InitializationKind &Kind,
5120 unsigned NumArgs) {
5121 switch (Entity.getKind()) {
5122 case InitializedEntity::EK_Temporary:
5123 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005124 case InitializedEntity::EK_RelatedResult:
Jordan Rose2624b812013-05-06 16:48:12 +00005125 break;
5126 default:
5127 return false;
5128 }
5129
5130 switch (Kind.getKind()) {
5131 case InitializationKind::IK_DirectList:
5132 return true;
5133 // FIXME: Hack to work around cast weirdness.
5134 case InitializationKind::IK_Direct:
5135 case InitializationKind::IK_Value:
5136 return NumArgs != 1;
5137 default:
5138 return false;
5139 }
5140}
5141
Sebastian Redl10f04a62011-12-22 14:44:04 +00005142static ExprResult
5143PerformConstructorInitialization(Sema &S,
5144 const InitializedEntity &Entity,
5145 const InitializationKind &Kind,
5146 MultiExprArg Args,
5147 const InitializationSequence::Step& Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005148 bool &ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00005149 bool IsListInitialization,
5150 SourceLocation LBraceLoc,
5151 SourceLocation RBraceLoc) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005152 unsigned NumArgs = Args.size();
5153 CXXConstructorDecl *Constructor
5154 = cast<CXXConstructorDecl>(Step.Function.Function);
5155 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5156
5157 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005158 SmallVector<Expr*, 8> ConstructorArgs;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005159 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5160 ? Kind.getEqualLoc()
5161 : Kind.getLocation();
5162
5163 if (Kind.getKind() == InitializationKind::IK_Default) {
5164 // Force even a trivial, implicit default constructor to be
5165 // semantically checked. We do this explicitly because we don't build
5166 // the definition for completely trivial constructors.
Matt Beaumont-Gay28e47022012-02-24 08:37:56 +00005167 assert(Constructor->getParent() && "No parent class for constructor.");
Sebastian Redl10f04a62011-12-22 14:44:04 +00005168 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Douglas Gregor5d86f612012-02-24 07:48:37 +00005169 Constructor->isTrivial() && !Constructor->isUsed(false))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005170 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5171 }
5172
5173 ExprResult CurInit = S.Owned((Expr *)0);
5174
Douglas Gregored878af2012-02-24 23:56:31 +00005175 // C++ [over.match.copy]p1:
5176 // - When initializing a temporary to be bound to the first parameter
5177 // of a constructor that takes a reference to possibly cv-qualified
5178 // T as its first argument, called with a single argument in the
5179 // context of direct-initialization, explicit conversion functions
5180 // are also considered.
5181 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5182 Args.size() == 1 &&
5183 Constructor->isCopyOrMoveConstructor();
5184
Sebastian Redl10f04a62011-12-22 14:44:04 +00005185 // Determine the arguments required to actually perform the constructor
5186 // call.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005187 if (S.CompleteConstructorCall(Constructor, Args,
Douglas Gregored878af2012-02-24 23:56:31 +00005188 Loc, ConstructorArgs,
Richard Smitha4dc51b2013-02-05 05:52:24 +00005189 AllowExplicitConv,
5190 IsListInitialization))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005191 return ExprError();
5192
5193
Jordan Rose2624b812013-05-06 16:48:12 +00005194 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005195 // An explicitly-constructed temporary, e.g., X(1, 2).
Eli Friedman5f2987c2012-02-02 03:46:19 +00005196 S.MarkFunctionReferenced(Loc, Constructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005197 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5198 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005199
5200 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5201 if (!TSInfo)
5202 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
Enea Zaffanella1245a542013-09-07 05:49:53 +00005203 SourceRange ParenOrBraceRange =
5204 (Kind.getKind() == InitializationKind::IK_DirectList)
5205 ? SourceRange(LBraceLoc, RBraceLoc)
5206 : Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005207
Richard Smithc83c2302012-12-19 01:39:02 +00005208 CurInit = S.Owned(
5209 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor,
5210 TSInfo, ConstructorArgs,
Enea Zaffanella1245a542013-09-07 05:49:53 +00005211 ParenOrBraceRange,
Richard Smithc83c2302012-12-19 01:39:02 +00005212 HadMultipleCandidates,
Enea Zaffanella14dcaa92013-09-07 11:22:02 +00005213 IsListInitialization,
Richard Smithc83c2302012-12-19 01:39:02 +00005214 ConstructorInitRequiresZeroInit));
Sebastian Redl10f04a62011-12-22 14:44:04 +00005215 } else {
5216 CXXConstructExpr::ConstructionKind ConstructKind =
5217 CXXConstructExpr::CK_Complete;
5218
5219 if (Entity.getKind() == InitializedEntity::EK_Base) {
5220 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5221 CXXConstructExpr::CK_VirtualBase :
5222 CXXConstructExpr::CK_NonVirtualBase;
5223 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5224 ConstructKind = CXXConstructExpr::CK_Delegating;
5225 }
5226
Stephen Hines651f13c2014-04-23 16:59:28 -07005227 // Only get the parenthesis or brace range if it is a list initialization or
5228 // direct construction.
5229 SourceRange ParenOrBraceRange;
5230 if (IsListInitialization)
5231 ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5232 else if (Kind.getKind() == InitializationKind::IK_Direct)
5233 ParenOrBraceRange = Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005234
5235 // If the entity allows NRVO, mark the construction as elidable
5236 // unconditionally.
5237 if (Entity.allowsNRVO())
5238 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5239 Constructor, /*Elidable=*/true,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005240 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005241 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005242 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005243 ConstructorInitRequiresZeroInit,
5244 ConstructKind,
Stephen Hines651f13c2014-04-23 16:59:28 -07005245 ParenOrBraceRange);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005246 else
5247 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5248 Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005249 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005250 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005251 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005252 ConstructorInitRequiresZeroInit,
5253 ConstructKind,
Stephen Hines651f13c2014-04-23 16:59:28 -07005254 ParenOrBraceRange);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005255 }
5256 if (CurInit.isInvalid())
5257 return ExprError();
5258
5259 // Only check access if all of that succeeded.
5260 S.CheckConstructorAccess(Loc, Constructor, Entity,
5261 Step.Function.FoundDecl.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005262 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5263 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005264
5265 if (shouldBindAsTemporary(Entity))
Richard Smith7c3e6152013-06-12 22:31:48 +00005266 CurInit = S.MaybeBindToTemporary(CurInit.take());
Sebastian Redl10f04a62011-12-22 14:44:04 +00005267
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005268 return CurInit;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005269}
5270
Richard Smith36d02af2012-06-04 22:27:30 +00005271/// Determine whether the specified InitializedEntity definitely has a lifetime
5272/// longer than the current full-expression. Conservatively returns false if
5273/// it's unclear.
5274static bool
5275InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5276 const InitializedEntity *Top = &Entity;
5277 while (Top->getParent())
5278 Top = Top->getParent();
5279
5280 switch (Top->getKind()) {
5281 case InitializedEntity::EK_Variable:
5282 case InitializedEntity::EK_Result:
5283 case InitializedEntity::EK_Exception:
5284 case InitializedEntity::EK_Member:
5285 case InitializedEntity::EK_New:
5286 case InitializedEntity::EK_Base:
5287 case InitializedEntity::EK_Delegating:
5288 return true;
5289
5290 case InitializedEntity::EK_ArrayElement:
5291 case InitializedEntity::EK_VectorElement:
5292 case InitializedEntity::EK_BlockElement:
5293 case InitializedEntity::EK_ComplexElement:
5294 // Could not determine what the full initialization is. Assume it might not
5295 // outlive the full-expression.
5296 return false;
5297
5298 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005299 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith36d02af2012-06-04 22:27:30 +00005300 case InitializedEntity::EK_Temporary:
5301 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00005302 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005303 case InitializedEntity::EK_RelatedResult:
Richard Smith36d02af2012-06-04 22:27:30 +00005304 // The entity being initialized might not outlive the full-expression.
5305 return false;
5306 }
5307
5308 llvm_unreachable("unknown entity kind");
5309}
5310
Richard Smith211c8dd2013-06-05 00:46:14 +00005311/// Determine the declaration which an initialized entity ultimately refers to,
5312/// for the purpose of lifetime-extending a temporary bound to a reference in
5313/// the initialization of \p Entity.
5314static const ValueDecl *
5315getDeclForTemporaryLifetimeExtension(const InitializedEntity &Entity,
5316 const ValueDecl *FallbackDecl = 0) {
5317 // C++11 [class.temporary]p5:
5318 switch (Entity.getKind()) {
5319 case InitializedEntity::EK_Variable:
5320 // The temporary [...] persists for the lifetime of the reference
5321 return Entity.getDecl();
5322
5323 case InitializedEntity::EK_Member:
5324 // For subobjects, we look at the complete object.
5325 if (Entity.getParent())
5326 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5327 Entity.getDecl());
5328
5329 // except:
5330 // -- A temporary bound to a reference member in a constructor's
5331 // ctor-initializer persists until the constructor exits.
5332 return Entity.getDecl();
5333
5334 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005335 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith211c8dd2013-06-05 00:46:14 +00005336 // -- A temporary bound to a reference parameter in a function call
5337 // persists until the completion of the full-expression containing
5338 // the call.
5339 case InitializedEntity::EK_Result:
5340 // -- The lifetime of a temporary bound to the returned value in a
5341 // function return statement is not extended; the temporary is
5342 // destroyed at the end of the full-expression in the return statement.
5343 case InitializedEntity::EK_New:
5344 // -- A temporary bound to a reference in a new-initializer persists
5345 // until the completion of the full-expression containing the
5346 // new-initializer.
5347 return 0;
5348
5349 case InitializedEntity::EK_Temporary:
5350 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005351 case InitializedEntity::EK_RelatedResult:
Richard Smith211c8dd2013-06-05 00:46:14 +00005352 // We don't yet know the storage duration of the surrounding temporary.
5353 // Assume it's got full-expression duration for now, it will patch up our
5354 // storage duration if that's not correct.
5355 return 0;
5356
5357 case InitializedEntity::EK_ArrayElement:
5358 // For subobjects, we look at the complete object.
5359 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5360 FallbackDecl);
5361
5362 case InitializedEntity::EK_Base:
5363 case InitializedEntity::EK_Delegating:
5364 // We can reach this case for aggregate initialization in a constructor:
5365 // struct A { int &&r; };
5366 // struct B : A { B() : A{0} {} };
5367 // In this case, use the innermost field decl as the context.
5368 return FallbackDecl;
5369
5370 case InitializedEntity::EK_BlockElement:
5371 case InitializedEntity::EK_LambdaCapture:
5372 case InitializedEntity::EK_Exception:
5373 case InitializedEntity::EK_VectorElement:
5374 case InitializedEntity::EK_ComplexElement:
Richard Smithd6b69872013-06-15 00:30:29 +00005375 return 0;
Richard Smith211c8dd2013-06-05 00:46:14 +00005376 }
Benjamin Kramer6f773e82013-06-05 15:37:50 +00005377 llvm_unreachable("unknown entity kind");
Richard Smith211c8dd2013-06-05 00:46:14 +00005378}
5379
5380static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD);
5381
5382/// Update a glvalue expression that is used as the initializer of a reference
5383/// to note that its lifetime is extended.
Richard Smithd6b69872013-06-15 00:30:29 +00005384/// \return \c true if any temporary had its lifetime extended.
5385static bool performReferenceExtension(Expr *Init, const ValueDecl *ExtendingD) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005386 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5387 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5388 // This is just redundant braces around an initializer. Step over it.
5389 Init = ILE->getInit(0);
5390 }
5391 }
5392
Richard Smithd6b69872013-06-15 00:30:29 +00005393 // Walk past any constructs which we can lifetime-extend across.
5394 Expr *Old;
5395 do {
5396 Old = Init;
5397
5398 // Step over any subobject adjustments; we may have a materialized
5399 // temporary inside them.
5400 SmallVector<const Expr *, 2> CommaLHSs;
5401 SmallVector<SubobjectAdjustment, 2> Adjustments;
5402 Init = const_cast<Expr *>(
5403 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5404
5405 // Per current approach for DR1376, look through casts to reference type
5406 // when performing lifetime extension.
5407 if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5408 if (CE->getSubExpr()->isGLValue())
5409 Init = CE->getSubExpr();
5410
5411 // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5412 // It's unclear if binding a reference to that xvalue extends the array
5413 // temporary.
5414 } while (Init != Old);
5415
Richard Smith211c8dd2013-06-05 00:46:14 +00005416 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5417 // Update the storage duration of the materialized temporary.
5418 // FIXME: Rebuild the expression instead of mutating it.
5419 ME->setExtendingDecl(ExtendingD);
5420 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingD);
Richard Smithd6b69872013-06-15 00:30:29 +00005421 return true;
Richard Smith211c8dd2013-06-05 00:46:14 +00005422 }
Richard Smithd6b69872013-06-15 00:30:29 +00005423
5424 return false;
Richard Smith211c8dd2013-06-05 00:46:14 +00005425}
5426
5427/// Update a prvalue expression that is going to be materialized as a
5428/// lifetime-extended temporary.
5429static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD) {
5430 // Dig out the expression which constructs the extended temporary.
5431 SmallVector<const Expr *, 2> CommaLHSs;
5432 SmallVector<SubobjectAdjustment, 2> Adjustments;
5433 Init = const_cast<Expr *>(
5434 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5435
Richard Smith8a07cd32013-06-12 20:42:33 +00005436 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5437 Init = BTE->getSubExpr();
5438
Richard Smith7c3e6152013-06-12 22:31:48 +00005439 if (CXXStdInitializerListExpr *ILE =
Richard Smithd6b69872013-06-15 00:30:29 +00005440 dyn_cast<CXXStdInitializerListExpr>(Init)) {
5441 performReferenceExtension(ILE->getSubExpr(), ExtendingD);
5442 return;
5443 }
Richard Smith7c3e6152013-06-12 22:31:48 +00005444
Richard Smith211c8dd2013-06-05 00:46:14 +00005445 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
Richard Smith7c3e6152013-06-12 22:31:48 +00005446 if (ILE->getType()->isArrayType()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005447 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5448 performLifetimeExtension(ILE->getInit(I), ExtendingD);
5449 return;
5450 }
5451
Richard Smith7c3e6152013-06-12 22:31:48 +00005452 if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005453 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5454
5455 // If we lifetime-extend a braced initializer which is initializing an
5456 // aggregate, and that aggregate contains reference members which are
5457 // bound to temporaries, those temporaries are also lifetime-extended.
5458 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5459 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5460 performReferenceExtension(ILE->getInit(0), ExtendingD);
5461 else {
5462 unsigned Index = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -07005463 for (const auto *I : RD->fields()) {
Richard Smith3c3af142013-07-01 06:08:20 +00005464 if (Index >= ILE->getNumInits())
5465 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00005466 if (I->isUnnamedBitfield())
5467 continue;
Richard Smith5771aab2013-06-27 22:54:33 +00005468 Expr *SubInit = ILE->getInit(Index);
Richard Smith211c8dd2013-06-05 00:46:14 +00005469 if (I->getType()->isReferenceType())
Richard Smith5771aab2013-06-27 22:54:33 +00005470 performReferenceExtension(SubInit, ExtendingD);
5471 else if (isa<InitListExpr>(SubInit) ||
5472 isa<CXXStdInitializerListExpr>(SubInit))
Richard Smith211c8dd2013-06-05 00:46:14 +00005473 // This may be either aggregate-initialization of a member or
5474 // initialization of a std::initializer_list object. Either way,
5475 // we should recursively lifetime-extend that initializer.
Richard Smith5771aab2013-06-27 22:54:33 +00005476 performLifetimeExtension(SubInit, ExtendingD);
Richard Smith211c8dd2013-06-05 00:46:14 +00005477 ++Index;
5478 }
5479 }
5480 }
5481 }
5482}
5483
Richard Smith7c3e6152013-06-12 22:31:48 +00005484static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5485 const Expr *Init, bool IsInitializerList,
5486 const ValueDecl *ExtendingDecl) {
5487 // Warn if a field lifetime-extends a temporary.
5488 if (isa<FieldDecl>(ExtendingDecl)) {
5489 if (IsInitializerList) {
5490 S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5491 << /*at end of constructor*/true;
5492 return;
5493 }
5494
5495 bool IsSubobjectMember = false;
5496 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5497 Ent = Ent->getParent()) {
5498 if (Ent->getKind() != InitializedEntity::EK_Base) {
5499 IsSubobjectMember = true;
5500 break;
5501 }
5502 }
5503 S.Diag(Init->getExprLoc(),
5504 diag::warn_bind_ref_member_to_temporary)
5505 << ExtendingDecl << Init->getSourceRange()
5506 << IsSubobjectMember << IsInitializerList;
5507 if (IsSubobjectMember)
5508 S.Diag(ExtendingDecl->getLocation(),
5509 diag::note_ref_subobject_of_member_declared_here);
5510 else
5511 S.Diag(ExtendingDecl->getLocation(),
5512 diag::note_ref_or_ptr_member_declared_here)
5513 << /*is pointer*/false;
5514 }
5515}
5516
Richard Smith13b228d2013-09-21 21:19:19 +00005517static void DiagnoseNarrowingInInitList(Sema &S,
5518 const ImplicitConversionSequence &ICS,
5519 QualType PreNarrowingType,
5520 QualType EntityType,
5521 const Expr *PostInit);
5522
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005523ExprResult
Douglas Gregor20093b42009-12-09 23:02:17 +00005524InitializationSequence::Perform(Sema &S,
5525 const InitializedEntity &Entity,
5526 const InitializationKind &Kind,
John McCallf312b1e2010-08-26 23:41:50 +00005527 MultiExprArg Args,
Douglas Gregord87b61f2009-12-10 17:56:55 +00005528 QualType *ResultType) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00005529 if (Failed()) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00005530 Diagnose(S, Entity, Kind, Args);
John McCallf312b1e2010-08-26 23:41:50 +00005531 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005532 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005533
Sebastian Redl7491c492011-06-05 13:59:11 +00005534 if (getKind() == DependentSequence) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005535 // If the declaration is a non-dependent, incomplete array type
5536 // that has an initializer, then its type will be completed once
5537 // the initializer is instantiated.
Douglas Gregord6542d82009-12-22 15:35:07 +00005538 if (ResultType && !Entity.getType()->isDependentType() &&
Douglas Gregord87b61f2009-12-10 17:56:55 +00005539 Args.size() == 1) {
Douglas Gregord6542d82009-12-22 15:35:07 +00005540 QualType DeclType = Entity.getType();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005541 if (const IncompleteArrayType *ArrayT
5542 = S.Context.getAsIncompleteArrayType(DeclType)) {
5543 // FIXME: We don't currently have the ability to accurately
5544 // compute the length of an initializer list without
5545 // performing full type-checking of the initializer list
5546 // (since we have to determine where braces are implicitly
5547 // introduced and such). So, we fall back to making the array
5548 // type a dependently-sized array type with no specified
5549 // bound.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005550 if (isa<InitListExpr>((Expr *)Args[0])) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005551 SourceRange Brackets;
Douglas Gregord6542d82009-12-22 15:35:07 +00005552
Douglas Gregord87b61f2009-12-10 17:56:55 +00005553 // Scavange the location of the brackets from the entity, if we can.
Douglas Gregord6542d82009-12-22 15:35:07 +00005554 if (DeclaratorDecl *DD = Entity.getDecl()) {
5555 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
5556 TypeLoc TL = TInfo->getTypeLoc();
David Blaikie39e6ab42013-02-18 22:06:02 +00005557 if (IncompleteArrayTypeLoc ArrayLoc =
5558 TL.getAs<IncompleteArrayTypeLoc>())
5559 Brackets = ArrayLoc.getBracketsRange();
Douglas Gregord6542d82009-12-22 15:35:07 +00005560 }
Douglas Gregord87b61f2009-12-10 17:56:55 +00005561 }
5562
5563 *ResultType
5564 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
5565 /*NumElts=*/0,
5566 ArrayT->getSizeModifier(),
5567 ArrayT->getIndexTypeCVRQualifiers(),
5568 Brackets);
5569 }
5570
5571 }
5572 }
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005573 if (Kind.getKind() == InitializationKind::IK_Direct &&
5574 !Kind.isExplicitCast()) {
5575 // Rebuild the ParenListExpr.
5576 SourceRange ParenRange = Kind.getParenRange();
5577 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005578 Args);
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005579 }
Manuel Klimek0d9106f2011-06-22 20:02:16 +00005580 assert(Kind.getKind() == InitializationKind::IK_Copy ||
Douglas Gregora9b55a42012-04-04 04:06:51 +00005581 Kind.isExplicitCast() ||
5582 Kind.getKind() == InitializationKind::IK_DirectList);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005583 return ExprResult(Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00005584 }
5585
Sebastian Redl7491c492011-06-05 13:59:11 +00005586 // No steps means no initialization.
5587 if (Steps.empty())
Douglas Gregor99a2e602009-12-16 01:38:02 +00005588 return S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005589
Richard Smith80ad52f2013-01-02 11:42:31 +00005590 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005591 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005592 !Entity.isParameterKind()) {
Richard Smith03544fc2012-04-19 06:58:00 +00005593 // Produce a C++98 compatibility warning if we are initializing a reference
5594 // from an initializer list. For parameters, we produce a better warning
5595 // elsewhere.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005596 Expr *Init = Args[0];
Richard Smith03544fc2012-04-19 06:58:00 +00005597 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
5598 << Init->getSourceRange();
5599 }
5600
Richard Smith36d02af2012-06-04 22:27:30 +00005601 // Diagnose cases where we initialize a pointer to an array temporary, and the
5602 // pointer obviously outlives the temporary.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005603 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Richard Smith36d02af2012-06-04 22:27:30 +00005604 Entity.getType()->isPointerType() &&
5605 InitializedEntityOutlivesFullExpression(Entity)) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005606 Expr *Init = Args[0];
Richard Smith36d02af2012-06-04 22:27:30 +00005607 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
5608 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
5609 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
5610 << Init->getSourceRange();
5611 }
5612
Douglas Gregord6542d82009-12-22 15:35:07 +00005613 QualType DestType = Entity.getType().getNonReferenceType();
5614 // FIXME: Ugly hack around the fact that Entity.getType() is not
Eli Friedmana91eb542009-12-22 02:10:53 +00005615 // the same as Entity.getDecl()->getType() in cases involving type merging,
5616 // and we want latter when it makes sense.
Douglas Gregord87b61f2009-12-10 17:56:55 +00005617 if (ResultType)
Eli Friedmana91eb542009-12-22 02:10:53 +00005618 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
Douglas Gregord6542d82009-12-22 15:35:07 +00005619 Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005620
John McCall60d7b3a2010-08-24 06:29:42 +00005621 ExprResult CurInit = S.Owned((Expr *)0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005622
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005623 // For initialization steps that start with a single initializer,
Douglas Gregor99a2e602009-12-16 01:38:02 +00005624 // grab the only argument out the Args and place it into the "current"
5625 // initializer.
5626 switch (Steps.front().Kind) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005627 case SK_ResolveAddressOfOverloadedFunction:
5628 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005629 case SK_CastDerivedToBaseXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005630 case SK_CastDerivedToBaseLValue:
5631 case SK_BindReference:
5632 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00005633 case SK_ExtraneousCopyToTemporary:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005634 case SK_UserConversion:
5635 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005636 case SK_QualificationConversionXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005637 case SK_QualificationConversionRValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00005638 case SK_LValueToRValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005639 case SK_ConversionSequence:
Richard Smith13b228d2013-09-21 21:19:19 +00005640 case SK_ConversionSequenceNoNarrowing:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005641 case SK_ListInitialization:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005642 case SK_UnwrapInitList:
5643 case SK_RewrapInitList:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005644 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005645 case SK_StringInit:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005646 case SK_ObjCObjectConversion:
John McCallf85e1932011-06-15 23:02:42 +00005647 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00005648 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00005649 case SK_PassByIndirectCopyRestore:
5650 case SK_PassByIndirectRestore:
Sebastian Redl2b916b82012-01-17 22:49:42 +00005651 case SK_ProduceObjCObject:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005652 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00005653 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005654 case SK_OCLZeroEvent: {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005655 assert(Args.size() == 1);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005656 CurInit = Args[0];
John Wiegley429bb272011-04-08 18:41:53 +00005657 if (!CurInit.get()) return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005658 break;
John McCallf6a16482010-12-04 03:47:34 +00005659 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005660
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005661 case SK_ConstructorInitialization:
Richard Smithf4bb8d02012-07-05 08:39:21 +00005662 case SK_ListConstructorCall:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005663 case SK_ZeroInitialization:
5664 break;
Douglas Gregor20093b42009-12-09 23:02:17 +00005665 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005666
5667 // Walk through the computed steps for the initialization sequence,
Douglas Gregor20093b42009-12-09 23:02:17 +00005668 // performing the specified conversions along the way.
Douglas Gregor16006c92009-12-16 18:50:27 +00005669 bool ConstructorInitRequiresZeroInit = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00005670 for (step_iterator Step = step_begin(), StepEnd = step_end();
5671 Step != StepEnd; ++Step) {
5672 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005673 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005674
John Wiegley429bb272011-04-08 18:41:53 +00005675 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005676
Douglas Gregor20093b42009-12-09 23:02:17 +00005677 switch (Step->Kind) {
5678 case SK_ResolveAddressOfOverloadedFunction:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005679 // Overload resolution determined which function invoke; update the
Douglas Gregor20093b42009-12-09 23:02:17 +00005680 // initializer to reflect that choice.
John Wiegley429bb272011-04-08 18:41:53 +00005681 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
Richard Smith82f145d2013-05-04 06:44:46 +00005682 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
5683 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005684 CurInit = S.FixOverloadedFunctionReference(CurInit,
John McCall6bb80172010-03-30 21:47:33 +00005685 Step->Function.FoundDecl,
John McCall9aa472c2010-03-19 07:35:19 +00005686 Step->Function.Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00005687 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005688
Douglas Gregor20093b42009-12-09 23:02:17 +00005689 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005690 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00005691 case SK_CastDerivedToBaseLValue: {
5692 // We have a derived-to-base cast that produces either an rvalue or an
5693 // lvalue. Perform that cast.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005694
John McCallf871d0c2010-08-07 06:22:56 +00005695 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005696
Douglas Gregor20093b42009-12-09 23:02:17 +00005697 // Casts to inaccessible base classes are allowed with C-style casts.
5698 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
5699 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
John Wiegley429bb272011-04-08 18:41:53 +00005700 CurInit.get()->getLocStart(),
5701 CurInit.get()->getSourceRange(),
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005702 &BasePath, IgnoreBaseAccess))
John McCallf312b1e2010-08-26 23:41:50 +00005703 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005704
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005705 if (S.BasePathInvolvesVirtualBase(BasePath)) {
5706 QualType T = SourceType;
5707 if (const PointerType *Pointer = T->getAs<PointerType>())
5708 T = Pointer->getPointeeType();
5709 if (const RecordType *RecordTy = T->getAs<RecordType>())
John Wiegley429bb272011-04-08 18:41:53 +00005710 S.MarkVTableUsed(CurInit.get()->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005711 cast<CXXRecordDecl>(RecordTy->getDecl()));
5712 }
5713
John McCall5baba9d2010-08-25 10:28:54 +00005714 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005715 Step->Kind == SK_CastDerivedToBaseLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005716 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005717 (Step->Kind == SK_CastDerivedToBaseXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005718 VK_XValue :
5719 VK_RValue);
John McCallf871d0c2010-08-07 06:22:56 +00005720 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5721 Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005722 CK_DerivedToBase,
John McCall5baba9d2010-08-25 10:28:54 +00005723 CurInit.get(),
5724 &BasePath, VK));
Douglas Gregor20093b42009-12-09 23:02:17 +00005725 break;
5726 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005727
Douglas Gregor20093b42009-12-09 23:02:17 +00005728 case SK_BindReference:
John McCall993f43f2013-05-06 21:39:12 +00005729 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
5730 if (CurInit.get()->refersToBitField()) {
5731 // We don't necessarily have an unambiguous source bit-field.
5732 FieldDecl *BitField = CurInit.get()->getSourceBitField();
Douglas Gregor20093b42009-12-09 23:02:17 +00005733 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
Douglas Gregord6542d82009-12-22 15:35:07 +00005734 << Entity.getType().isVolatileQualified()
John McCall993f43f2013-05-06 21:39:12 +00005735 << (BitField ? BitField->getDeclName() : DeclarationName())
5736 << (BitField != NULL)
John Wiegley429bb272011-04-08 18:41:53 +00005737 << CurInit.get()->getSourceRange();
John McCall993f43f2013-05-06 21:39:12 +00005738 if (BitField)
5739 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
5740
John McCallf312b1e2010-08-26 23:41:50 +00005741 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005742 }
Anders Carlssona6fe0bf2010-01-29 02:47:33 +00005743
John Wiegley429bb272011-04-08 18:41:53 +00005744 if (CurInit.get()->refersToVectorElement()) {
John McCall41593e32010-02-02 19:02:38 +00005745 // References cannot bind to vector elements.
Anders Carlsson09380262010-01-31 17:18:49 +00005746 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5747 << Entity.getType().isVolatileQualified()
John Wiegley429bb272011-04-08 18:41:53 +00005748 << CurInit.get()->getSourceRange();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005749 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005750 return ExprError();
Anders Carlsson09380262010-01-31 17:18:49 +00005751 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005752
Douglas Gregor20093b42009-12-09 23:02:17 +00005753 // Reference binding does not have any corresponding ASTs.
5754
5755 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005756 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005757 return ExprError();
Anders Carlsson3aba0932010-01-31 18:34:51 +00005758
Richard Smithd6b69872013-06-15 00:30:29 +00005759 // Even though we didn't materialize a temporary, the binding may still
5760 // extend the lifetime of a temporary. This happens if we bind a reference
5761 // to the result of a cast to reference type.
5762 if (const ValueDecl *ExtendingDecl =
5763 getDeclForTemporaryLifetimeExtension(Entity)) {
5764 if (performReferenceExtension(CurInit.get(), ExtendingDecl))
5765 warnOnLifetimeExtension(S, Entity, CurInit.get(), false,
5766 ExtendingDecl);
5767 }
5768
Douglas Gregor20093b42009-12-09 23:02:17 +00005769 break;
Anders Carlsson3aba0932010-01-31 18:34:51 +00005770
Richard Smith211c8dd2013-06-05 00:46:14 +00005771 case SK_BindReferenceToTemporary: {
Jordan Rose1fd1e282013-04-11 00:58:58 +00005772 // Make sure the "temporary" is actually an rvalue.
5773 assert(CurInit.get()->isRValue() && "not a temporary");
5774
Douglas Gregor20093b42009-12-09 23:02:17 +00005775 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005776 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005777 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005778
Richard Smith211c8dd2013-06-05 00:46:14 +00005779 // Maybe lifetime-extend the temporary's subobjects to match the
5780 // entity's lifetime.
5781 const ValueDecl *ExtendingDecl =
5782 getDeclForTemporaryLifetimeExtension(Entity);
Richard Smitha4bb99c2013-06-12 21:51:50 +00005783 if (ExtendingDecl) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005784 performLifetimeExtension(CurInit.get(), ExtendingDecl);
Richard Smith7c3e6152013-06-12 22:31:48 +00005785 warnOnLifetimeExtension(S, Entity, CurInit.get(), false, ExtendingDecl);
Richard Smitha4bb99c2013-06-12 21:51:50 +00005786 }
5787
Douglas Gregor03e80032011-06-21 17:03:29 +00005788 // Materialize the temporary into memory.
Richard Smith8a07cd32013-06-12 20:42:33 +00005789 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
Richard Smith211c8dd2013-06-05 00:46:14 +00005790 Entity.getType().getNonReferenceType(), CurInit.get(),
5791 Entity.getType()->isLValueReferenceType(), ExtendingDecl);
Douglas Gregord7b23162011-06-22 16:12:01 +00005792
5793 // If we're binding to an Objective-C object that has lifetime, we
Richard Smith8a07cd32013-06-12 20:42:33 +00005794 // need cleanups. Likewise if we're extending this temporary to automatic
5795 // storage duration -- we need to register its cleanup during the
5796 // full-expression's cleanups.
5797 if ((S.getLangOpts().ObjCAutoRefCount &&
5798 MTE->getType()->isObjCLifetimeType()) ||
5799 (MTE->getStorageDuration() == SD_Automatic &&
5800 MTE->getType().isDestructedType()))
Douglas Gregord7b23162011-06-22 16:12:01 +00005801 S.ExprNeedsCleanups = true;
Richard Smith8a07cd32013-06-12 20:42:33 +00005802
5803 CurInit = S.Owned(MTE);
Douglas Gregor20093b42009-12-09 23:02:17 +00005804 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00005805 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005806
Douglas Gregor523d46a2010-04-18 07:40:54 +00005807 case SK_ExtraneousCopyToTemporary:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005808 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
Douglas Gregor523d46a2010-04-18 07:40:54 +00005809 /*IsExtraneousCopy=*/true);
5810 break;
5811
Douglas Gregor20093b42009-12-09 23:02:17 +00005812 case SK_UserConversion: {
5813 // We have a user-defined conversion that invokes either a constructor
5814 // or a conversion function.
John McCalldaa8e4e2010-11-15 09:13:47 +00005815 CastKind CastKind;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005816 bool IsCopy = false;
John McCall9aa472c2010-03-19 07:35:19 +00005817 FunctionDecl *Fn = Step->Function.Function;
5818 DeclAccessPair FoundFn = Step->Function.FoundDecl;
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005819 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005820 bool CreatedObject = false;
John McCallb13b7372010-02-01 03:16:54 +00005821 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00005822 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005823 SmallVector<Expr*, 8> ConstructorArgs;
John Wiegley429bb272011-04-08 18:41:53 +00005824 SourceLocation Loc = CurInit.get()->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00005825 CurInit.release(); // Ownership transferred into MultiExprArg, below.
John McCallb13b7372010-02-01 03:16:54 +00005826
Douglas Gregor20093b42009-12-09 23:02:17 +00005827 // Determine the arguments required to actually perform the constructor
5828 // call.
John Wiegley429bb272011-04-08 18:41:53 +00005829 Expr *Arg = CurInit.get();
Douglas Gregor20093b42009-12-09 23:02:17 +00005830 if (S.CompleteConstructorCall(Constructor,
John Wiegley429bb272011-04-08 18:41:53 +00005831 MultiExprArg(&Arg, 1),
Douglas Gregor20093b42009-12-09 23:02:17 +00005832 Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005833 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005834
Richard Smithf2e4dfc2012-02-11 19:22:50 +00005835 // Build an expression that constructs a temporary.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005836 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005837 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005838 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005839 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005840 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005841 CXXConstructExpr::CK_Complete,
5842 SourceRange());
Douglas Gregor20093b42009-12-09 23:02:17 +00005843 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005844 return ExprError();
John McCallb13b7372010-02-01 03:16:54 +00005845
Anders Carlsson9a68a672010-04-21 18:47:17 +00005846 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
John McCall9aa472c2010-03-19 07:35:19 +00005847 FoundFn.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005848 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5849 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005850
John McCall2de56d12010-08-25 11:45:40 +00005851 CastKind = CK_ConstructorConversion;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005852 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5853 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5854 S.IsDerivedFrom(SourceType, Class))
5855 IsCopy = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005856
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005857 CreatedObject = true;
Douglas Gregor20093b42009-12-09 23:02:17 +00005858 } else {
5859 // Build a call to the conversion function.
John McCallb13b7372010-02-01 03:16:54 +00005860 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
John Wiegley429bb272011-04-08 18:41:53 +00005861 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), 0,
John McCall9aa472c2010-03-19 07:35:19 +00005862 FoundFn);
Richard Smith82f145d2013-05-04 06:44:46 +00005863 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5864 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005865
5866 // FIXME: Should we move this initialization into a separate
Douglas Gregor20093b42009-12-09 23:02:17 +00005867 // derived-to-base conversion? I believe the answer is "no", because
5868 // we don't want to turn off access control here for c-style casts.
John Wiegley429bb272011-04-08 18:41:53 +00005869 ExprResult CurInitExprRes =
5870 S.PerformObjectArgumentInitialization(CurInit.take(), /*Qualifier=*/0,
5871 FoundFn, Conversion);
5872 if(CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005873 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005874 CurInit = CurInitExprRes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005875
Douglas Gregor20093b42009-12-09 23:02:17 +00005876 // Build the actual call to the conversion function.
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005877 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5878 HadMultipleCandidates);
Douglas Gregor20093b42009-12-09 23:02:17 +00005879 if (CurInit.isInvalid() || !CurInit.get())
John McCallf312b1e2010-08-26 23:41:50 +00005880 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005881
John McCall2de56d12010-08-25 11:45:40 +00005882 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005883
Stephen Hines651f13c2014-04-23 16:59:28 -07005884 CreatedObject = Conversion->getReturnType()->isRecordType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005885 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005886
Sebastian Redl3b802322011-07-14 19:07:55 +00005887 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
Abramo Bagnara960809e2011-11-16 22:46:05 +00005888 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
5889
5890 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
John Wiegley429bb272011-04-08 18:41:53 +00005891 QualType T = CurInit.get()->getType();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005892 if (const RecordType *Record = T->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005893 CXXDestructorDecl *Destructor
Douglas Gregordb89f282010-07-01 22:47:18 +00005894 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
John Wiegley429bb272011-04-08 18:41:53 +00005895 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005896 S.PDiag(diag::err_access_dtor_temp) << T);
Eli Friedman5f2987c2012-02-02 03:46:19 +00005897 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005898 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
5899 return ExprError();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005900 }
5901 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005902
John McCallf871d0c2010-08-07 06:22:56 +00005903 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
John Wiegley429bb272011-04-08 18:41:53 +00005904 CurInit.get()->getType(),
5905 CastKind, CurInit.get(), 0,
Eli Friedman104be6f2011-09-27 01:11:35 +00005906 CurInit.get()->getValueKind()));
Abramo Bagnara960809e2011-11-16 22:46:05 +00005907 if (MaybeBindToTemp)
5908 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Douglas Gregor2f599792010-04-02 18:24:57 +00005909 if (RequiresCopy)
Douglas Gregor523d46a2010-04-18 07:40:54 +00005910 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005911 CurInit, /*IsExtraneousCopy=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00005912 break;
5913 }
Sebastian Redl906082e2010-07-20 04:20:21 +00005914
Douglas Gregor20093b42009-12-09 23:02:17 +00005915 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005916 case SK_QualificationConversionXValue:
5917 case SK_QualificationConversionRValue: {
Douglas Gregor20093b42009-12-09 23:02:17 +00005918 // Perform a qualification conversion; these can never go wrong.
John McCall5baba9d2010-08-25 10:28:54 +00005919 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005920 Step->Kind == SK_QualificationConversionLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005921 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005922 (Step->Kind == SK_QualificationConversionXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005923 VK_XValue :
5924 VK_RValue);
John Wiegley429bb272011-04-08 18:41:53 +00005925 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK);
Douglas Gregor20093b42009-12-09 23:02:17 +00005926 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00005927 }
5928
Jordan Rose1fd1e282013-04-11 00:58:58 +00005929 case SK_LValueToRValue: {
5930 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
5931 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
5932 CK_LValueToRValue,
5933 CurInit.take(),
5934 /*BasePath=*/0,
5935 VK_RValue));
5936 break;
5937 }
5938
Richard Smith13b228d2013-09-21 21:19:19 +00005939 case SK_ConversionSequence:
5940 case SK_ConversionSequenceNoNarrowing: {
5941 Sema::CheckedConversionKind CCK
John McCallf85e1932011-06-15 23:02:42 +00005942 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
5943 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
Richard Smithc8d7f582011-11-29 22:48:16 +00005944 : Kind.isExplicitCast()? Sema::CCK_OtherCast
John McCallf85e1932011-06-15 23:02:42 +00005945 : Sema::CCK_ImplicitConversion;
John Wiegley429bb272011-04-08 18:41:53 +00005946 ExprResult CurInitExprRes =
5947 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
John McCallf85e1932011-06-15 23:02:42 +00005948 getAssignmentAction(Entity), CCK);
John Wiegley429bb272011-04-08 18:41:53 +00005949 if (CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005950 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005951 CurInit = CurInitExprRes;
Richard Smith13b228d2013-09-21 21:19:19 +00005952
5953 if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
5954 S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
5955 DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
5956 CurInit.get());
Douglas Gregor20093b42009-12-09 23:02:17 +00005957 break;
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005958 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005959
Douglas Gregord87b61f2009-12-10 17:56:55 +00005960 case SK_ListInitialization: {
John Wiegley429bb272011-04-08 18:41:53 +00005961 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
Richard Smith7c3e6152013-06-12 22:31:48 +00005962 // If we're not initializing the top-level entity, we need to create an
5963 // InitializeTemporary entity for our target type.
5964 QualType Ty = Step->Type;
5965 bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005966 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
Richard Smith802e2262013-02-02 01:13:06 +00005967 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
5968 InitListChecker PerformInitList(S, InitEntity,
Richard Smith40cba902013-06-06 11:41:05 +00005969 InitList, Ty, /*VerifyOnly=*/false);
Sebastian Redl14b0c192011-09-24 17:48:00 +00005970 if (PerformInitList.HadError())
John McCallf312b1e2010-08-26 23:41:50 +00005971 return ExprError();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005972
Richard Smith7c3e6152013-06-12 22:31:48 +00005973 // Hack: We must update *ResultType if available in order to set the
5974 // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
5975 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
5976 if (ResultType &&
5977 ResultType->getNonReferenceType()->isIncompleteArrayType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005978 if ((*ResultType)->isRValueReferenceType())
5979 Ty = S.Context.getRValueReferenceType(Ty);
5980 else if ((*ResultType)->isLValueReferenceType())
5981 Ty = S.Context.getLValueReferenceType(Ty,
5982 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
5983 *ResultType = Ty;
5984 }
5985
5986 InitListExpr *StructuredInitList =
5987 PerformInitList.getFullyStructuredList();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005988 CurInit.release();
Richard Smith802e2262013-02-02 01:13:06 +00005989 CurInit = shouldBindAsTemporary(InitEntity)
5990 ? S.MaybeBindToTemporary(StructuredInitList)
5991 : S.Owned(StructuredInitList);
Douglas Gregord87b61f2009-12-10 17:56:55 +00005992 break;
5993 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00005994
Sebastian Redl10f04a62011-12-22 14:44:04 +00005995 case SK_ListConstructorCall: {
Sebastian Redl168319c2012-02-12 16:37:24 +00005996 // When an initializer list is passed for a parameter of type "reference
5997 // to object", we don't get an EK_Temporary entity, but instead an
5998 // EK_Parameter entity with reference type.
Sebastian Redlbac5cf42012-02-19 12:27:56 +00005999 // FIXME: This is a hack. What we really should do is create a user
6000 // conversion step for this case, but this makes it considerably more
6001 // complicated. For now, this will do.
Sebastian Redl168319c2012-02-12 16:37:24 +00006002 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6003 Entity.getType().getNonReferenceType());
6004 bool UseTemporary = Entity.getType()->isReferenceType();
Richard Smithf4bb8d02012-07-05 08:39:21 +00006005 assert(Args.size() == 1 && "expected a single argument for list init");
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006006 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Richard Smith03544fc2012-04-19 06:58:00 +00006007 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6008 << InitList->getSourceRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00006009 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
Sebastian Redl168319c2012-02-12 16:37:24 +00006010 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6011 Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006012 Kind, Arg, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00006013 ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00006014 /*IsListInitialization*/ true,
6015 InitList->getLBraceLoc(),
6016 InitList->getRBraceLoc());
Sebastian Redl10f04a62011-12-22 14:44:04 +00006017 break;
6018 }
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006019
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006020 case SK_UnwrapInitList:
6021 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0));
6022 break;
6023
6024 case SK_RewrapInitList: {
6025 Expr *E = CurInit.take();
6026 InitListExpr *Syntactic = Step->WrappingSyntacticList;
6027 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00006028 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006029 ILE->setSyntacticForm(Syntactic);
6030 ILE->setType(E->getType());
6031 ILE->setValueKind(E->getValueKind());
6032 CurInit = S.Owned(ILE);
6033 break;
6034 }
6035
Sebastian Redlbac5cf42012-02-19 12:27:56 +00006036 case SK_ConstructorInitialization: {
6037 // When an initializer list is passed for a parameter of type "reference
6038 // to object", we don't get an EK_Temporary entity, but instead an
6039 // EK_Parameter entity with reference type.
6040 // FIXME: This is a hack. What we really should do is create a user
6041 // conversion step for this case, but this makes it considerably more
6042 // complicated. For now, this will do.
6043 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6044 Entity.getType().getNonReferenceType());
6045 bool UseTemporary = Entity.getType()->isReferenceType();
6046 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity
6047 : Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006048 Kind, Args, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00006049 ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00006050 /*IsListInitialization*/ false,
6051 /*LBraceLoc*/ SourceLocation(),
6052 /*RBraceLoc*/ SourceLocation());
Douglas Gregor51c56d62009-12-14 20:49:26 +00006053 break;
Sebastian Redlbac5cf42012-02-19 12:27:56 +00006054 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006055
Douglas Gregor71d17402009-12-15 00:01:57 +00006056 case SK_ZeroInitialization: {
Douglas Gregor16006c92009-12-16 18:50:27 +00006057 step_iterator NextStep = Step;
6058 ++NextStep;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006059 if (NextStep != StepEnd &&
Richard Smithf4bb8d02012-07-05 08:39:21 +00006060 (NextStep->Kind == SK_ConstructorInitialization ||
6061 NextStep->Kind == SK_ListConstructorCall)) {
Douglas Gregor16006c92009-12-16 18:50:27 +00006062 // The need for zero-initialization is recorded directly into
6063 // the call to the object's constructor within the next step.
6064 ConstructorInitRequiresZeroInit = true;
6065 } else if (Kind.getKind() == InitializationKind::IK_Value &&
David Blaikie4e4d0842012-03-11 07:00:24 +00006066 S.getLangOpts().CPlusPlus &&
Douglas Gregor16006c92009-12-16 18:50:27 +00006067 !Kind.isImplicitValueInit()) {
Douglas Gregorab6677e2010-09-08 00:15:04 +00006068 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6069 if (!TSInfo)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006070 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
Douglas Gregorab6677e2010-09-08 00:15:04 +00006071 Kind.getRange().getBegin());
6072
6073 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr(
6074 TSInfo->getType().getNonLValueExprType(S.Context),
6075 TSInfo,
Douglas Gregor71d17402009-12-15 00:01:57 +00006076 Kind.getRange().getEnd()));
Douglas Gregor16006c92009-12-16 18:50:27 +00006077 } else {
Douglas Gregor71d17402009-12-15 00:01:57 +00006078 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
Douglas Gregor16006c92009-12-16 18:50:27 +00006079 }
Douglas Gregor71d17402009-12-15 00:01:57 +00006080 break;
6081 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006082
6083 case SK_CAssignment: {
John Wiegley429bb272011-04-08 18:41:53 +00006084 QualType SourceType = CurInit.get()->getType();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006085 ExprResult Result = CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006086 Sema::AssignConvertType ConvTy =
Fariborz Jahanian01ad0482013-07-31 21:40:51 +00006087 S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6088 Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
John Wiegley429bb272011-04-08 18:41:53 +00006089 if (Result.isInvalid())
6090 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006091 CurInit = Result;
Douglas Gregoraa037312009-12-22 07:24:36 +00006092
6093 // If this is a call, allow conversion to a transparent union.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006094 ExprResult CurInitExprRes = CurInit;
Douglas Gregoraa037312009-12-22 07:24:36 +00006095 if (ConvTy != Sema::Compatible &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006096 Entity.isParameterKind() &&
John Wiegley429bb272011-04-08 18:41:53 +00006097 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
Douglas Gregoraa037312009-12-22 07:24:36 +00006098 == Sema::Compatible)
6099 ConvTy = Sema::Compatible;
John Wiegley429bb272011-04-08 18:41:53 +00006100 if (CurInitExprRes.isInvalid())
6101 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006102 CurInit = CurInitExprRes;
Douglas Gregoraa037312009-12-22 07:24:36 +00006103
Douglas Gregora41a8c52010-04-22 00:20:18 +00006104 bool Complained;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006105 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6106 Step->Type, SourceType,
John Wiegley429bb272011-04-08 18:41:53 +00006107 CurInit.get(),
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00006108 getAssignmentAction(Entity, true),
Douglas Gregora41a8c52010-04-22 00:20:18 +00006109 &Complained)) {
6110 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00006111 return ExprError();
Douglas Gregora41a8c52010-04-22 00:20:18 +00006112 } else if (Complained)
6113 PrintInitLocationNote(S, Entity);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006114 break;
6115 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00006116
6117 case SK_StringInit: {
6118 QualType Ty = Step->Type;
John Wiegley429bb272011-04-08 18:41:53 +00006119 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
John McCallfef8b342011-02-21 07:57:55 +00006120 S.Context.getAsArrayType(Ty), S);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00006121 break;
6122 }
Douglas Gregor569c3162010-08-07 11:51:51 +00006123
6124 case SK_ObjCObjectConversion:
John Wiegley429bb272011-04-08 18:41:53 +00006125 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00006126 CK_ObjCObjectLValueCast,
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00006127 CurInit.get()->getValueKind());
Douglas Gregor569c3162010-08-07 11:51:51 +00006128 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006129
6130 case SK_ArrayInit:
6131 // Okay: we checked everything before creating this step. Note that
6132 // this is a GNU extension.
6133 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
John Wiegley429bb272011-04-08 18:41:53 +00006134 << Step->Type << CurInit.get()->getType()
6135 << CurInit.get()->getSourceRange();
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006136
6137 // If the destination type is an incomplete array type, update the
6138 // type accordingly.
6139 if (ResultType) {
6140 if (const IncompleteArrayType *IncompleteDest
6141 = S.Context.getAsIncompleteArrayType(Step->Type)) {
6142 if (const ConstantArrayType *ConstantSource
John Wiegley429bb272011-04-08 18:41:53 +00006143 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006144 *ResultType = S.Context.getConstantArrayType(
6145 IncompleteDest->getElementType(),
6146 ConstantSource->getSize(),
6147 ArrayType::Normal, 0);
6148 }
6149 }
6150 }
John McCallf85e1932011-06-15 23:02:42 +00006151 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006152
Richard Smith0f163e92012-02-15 22:38:09 +00006153 case SK_ParenthesizedArrayInit:
6154 // Okay: we checked everything before creating this step. Note that
6155 // this is a GNU extension.
6156 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6157 << CurInit.get()->getSourceRange();
6158 break;
6159
John McCallf85e1932011-06-15 23:02:42 +00006160 case SK_PassByIndirectCopyRestore:
6161 case SK_PassByIndirectRestore:
6162 checkIndirectCopyRestoreSource(S, CurInit.get());
6163 CurInit = S.Owned(new (S.Context)
6164 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type,
6165 Step->Kind == SK_PassByIndirectCopyRestore));
6166 break;
6167
6168 case SK_ProduceObjCObject:
6169 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
John McCall33e56f32011-09-10 06:18:15 +00006170 CK_ARCProduceObject,
John McCallf85e1932011-06-15 23:02:42 +00006171 CurInit.take(), 0, VK_RValue));
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006172 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006173
6174 case SK_StdInitializerList: {
Richard Smith7c3e6152013-06-12 22:31:48 +00006175 S.Diag(CurInit.get()->getExprLoc(),
6176 diag::warn_cxx98_compat_initializer_list_init)
6177 << CurInit.get()->getSourceRange();
Sebastian Redl28357452012-03-05 19:35:43 +00006178
Richard Smith7c3e6152013-06-12 22:31:48 +00006179 // Maybe lifetime-extend the array temporary's subobjects to match the
6180 // entity's lifetime.
6181 const ValueDecl *ExtendingDecl =
6182 getDeclForTemporaryLifetimeExtension(Entity);
6183 if (ExtendingDecl) {
6184 performLifetimeExtension(CurInit.get(), ExtendingDecl);
6185 warnOnLifetimeExtension(S, Entity, CurInit.get(), true, ExtendingDecl);
Sebastian Redl28357452012-03-05 19:35:43 +00006186 }
6187
Richard Smith7c3e6152013-06-12 22:31:48 +00006188 // Materialize the temporary into memory.
6189 MaterializeTemporaryExpr *MTE = new (S.Context)
6190 MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
6191 /*lvalue reference*/ false, ExtendingDecl);
6192
6193 // Wrap it in a construction of a std::initializer_list<T>.
6194 CurInit = S.Owned(
6195 new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE));
6196
6197 // Bind the result, in case the library has given initializer_list a
6198 // non-trivial destructor.
6199 if (shouldBindAsTemporary(Entity))
6200 CurInit = S.MaybeBindToTemporary(CurInit.take());
Sebastian Redl2b916b82012-01-17 22:49:42 +00006201 break;
6202 }
Richard Smith7c3e6152013-06-12 22:31:48 +00006203
Guy Benyei21f18c42013-02-07 10:55:47 +00006204 case SK_OCLSamplerInit: {
6205 assert(Step->Type->isSamplerT() &&
Stephen Hines651f13c2014-04-23 16:59:28 -07006206 "Sampler initialization on non-sampler type.");
Guy Benyei21f18c42013-02-07 10:55:47 +00006207
6208 QualType SourceType = CurInit.get()->getType();
Guy Benyei21f18c42013-02-07 10:55:47 +00006209
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006210 if (Entity.isParameterKind()) {
Guy Benyei21f18c42013-02-07 10:55:47 +00006211 if (!SourceType->isSamplerT())
6212 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6213 << SourceType;
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006214 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
Guy Benyei21f18c42013-02-07 10:55:47 +00006215 llvm_unreachable("Invalid EntityKind!");
6216 }
6217
6218 break;
6219 }
Guy Benyeie6b9d802013-01-20 12:31:11 +00006220 case SK_OCLZeroEvent: {
6221 assert(Step->Type->isEventT() &&
Stephen Hines651f13c2014-04-23 16:59:28 -07006222 "Event initialization on non-event type.");
Guy Benyeie6b9d802013-01-20 12:31:11 +00006223
6224 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
6225 CK_ZeroToOCLEvent,
6226 CurInit.get()->getValueKind());
6227 break;
6228 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006229 }
6230 }
John McCall15d7d122010-11-11 03:21:53 +00006231
6232 // Diagnose non-fatal problems with the completed initialization.
6233 if (Entity.getKind() == InitializedEntity::EK_Member &&
6234 cast<FieldDecl>(Entity.getDecl())->isBitField())
6235 S.CheckBitFieldInitialization(Kind.getLocation(),
6236 cast<FieldDecl>(Entity.getDecl()),
6237 CurInit.get());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006238
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006239 return CurInit;
Douglas Gregor20093b42009-12-09 23:02:17 +00006240}
6241
Richard Smithd5bc8672012-12-08 02:01:17 +00006242/// Somewhere within T there is an uninitialized reference subobject.
6243/// Dig it out and diagnose it.
Benjamin Kramera574c892013-02-15 12:30:38 +00006244static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6245 QualType T) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006246 if (T->isReferenceType()) {
6247 S.Diag(Loc, diag::err_reference_without_init)
6248 << T.getNonReferenceType();
6249 return true;
6250 }
6251
6252 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6253 if (!RD || !RD->hasUninitializedReferenceMember())
6254 return false;
6255
Stephen Hines651f13c2014-04-23 16:59:28 -07006256 for (const auto *FI : RD->fields()) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006257 if (FI->isUnnamedBitfield())
6258 continue;
6259
6260 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6261 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6262 return true;
6263 }
6264 }
6265
Stephen Hines651f13c2014-04-23 16:59:28 -07006266 for (const auto &BI : RD->bases()) {
6267 if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006268 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6269 return true;
6270 }
6271 }
6272
6273 return false;
6274}
6275
6276
Douglas Gregor20093b42009-12-09 23:02:17 +00006277//===----------------------------------------------------------------------===//
6278// Diagnose initialization failures
6279//===----------------------------------------------------------------------===//
John McCall7cca8212013-03-19 07:04:25 +00006280
6281/// Emit notes associated with an initialization that failed due to a
6282/// "simple" conversion failure.
6283static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6284 Expr *op) {
6285 QualType destType = entity.getType();
6286 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6287 op->getType()->isObjCObjectPointerType()) {
6288
6289 // Emit a possible note about the conversion failing because the
6290 // operand is a message send with a related result type.
6291 S.EmitRelatedResultTypeNote(op);
6292
6293 // Emit a possible note about a return failing because we're
6294 // expecting a related result type.
6295 if (entity.getKind() == InitializedEntity::EK_Result)
6296 S.EmitRelatedResultTypeNoteForReturn(destType);
6297 }
6298}
6299
Bill Wendling2ca3db42013-11-22 00:01:44 +00006300static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6301 InitListExpr *InitList) {
6302 QualType DestType = Entity.getType();
6303
6304 QualType E;
6305 if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6306 QualType ArrayType = S.Context.getConstantArrayType(
6307 E.withConst(),
6308 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6309 InitList->getNumInits()),
6310 clang::ArrayType::Normal, 0);
6311 InitializedEntity HiddenArray =
6312 InitializedEntity::InitializeTemporary(ArrayType);
6313 return diagnoseListInit(S, HiddenArray, InitList);
6314 }
6315
6316 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6317 /*VerifyOnly=*/false);
6318 assert(DiagnoseInitList.HadError() &&
6319 "Inconsistent init list check result.");
6320}
6321
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006322bool InitializationSequence::Diagnose(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00006323 const InitializedEntity &Entity,
6324 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006325 ArrayRef<Expr *> Args) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00006326 if (!Failed())
Douglas Gregor20093b42009-12-09 23:02:17 +00006327 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006328
Douglas Gregord6542d82009-12-22 15:35:07 +00006329 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00006330 switch (Failure) {
6331 case FK_TooManyInitsForReference:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006332 // FIXME: Customize for the initialized entity?
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006333 if (Args.empty()) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006334 // Dig out the reference subobject which is uninitialized and diagnose it.
6335 // If this is value-initialization, this could be nested some way within
6336 // the target type.
6337 assert(Kind.getKind() == InitializationKind::IK_Value ||
6338 DestType->isReferenceType());
6339 bool Diagnosed =
6340 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6341 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6342 (void)Diagnosed;
6343 } else // FIXME: diagnostic below could be better!
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006344 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006345 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
Douglas Gregor20093b42009-12-09 23:02:17 +00006346 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006347
Douglas Gregor20093b42009-12-09 23:02:17 +00006348 case FK_ArrayNeedsInitList:
Hans Wennborg0ff50742013-05-15 11:03:04 +00006349 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
Douglas Gregor20093b42009-12-09 23:02:17 +00006350 break;
Hans Wennborg0ff50742013-05-15 11:03:04 +00006351 case FK_ArrayNeedsInitListOrStringLiteral:
6352 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6353 break;
6354 case FK_ArrayNeedsInitListOrWideStringLiteral:
6355 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6356 break;
6357 case FK_NarrowStringIntoWideCharArray:
6358 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6359 break;
6360 case FK_WideStringIntoCharArray:
6361 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6362 break;
6363 case FK_IncompatWideStringIntoWideChar:
6364 S.Diag(Kind.getLocation(),
6365 diag::err_array_init_incompat_wide_string_into_wchar);
6366 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006367 case FK_ArrayTypeMismatch:
6368 case FK_NonConstantArrayInit:
Bill Wendling2ca3db42013-11-22 00:01:44 +00006369 S.Diag(Kind.getLocation(),
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006370 (Failure == FK_ArrayTypeMismatch
6371 ? diag::err_array_init_different_type
6372 : diag::err_array_init_non_constant_array))
6373 << DestType.getNonReferenceType()
6374 << Args[0]->getType()
6375 << Args[0]->getSourceRange();
6376 break;
6377
John McCall73076432012-01-05 00:13:19 +00006378 case FK_VariableLengthArrayHasInitializer:
6379 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6380 << Args[0]->getSourceRange();
6381 break;
6382
John McCall6bb80172010-03-30 21:47:33 +00006383 case FK_AddressOfOverloadFailed: {
6384 DeclAccessPair Found;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006385 S.ResolveAddressOfOverloadedFunction(Args[0],
Douglas Gregor20093b42009-12-09 23:02:17 +00006386 DestType.getNonReferenceType(),
John McCall6bb80172010-03-30 21:47:33 +00006387 true,
6388 Found);
Douglas Gregor20093b42009-12-09 23:02:17 +00006389 break;
John McCall6bb80172010-03-30 21:47:33 +00006390 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006391
Douglas Gregor20093b42009-12-09 23:02:17 +00006392 case FK_ReferenceInitOverloadFailed:
Douglas Gregor4a520a22009-12-14 17:27:33 +00006393 case FK_UserConversionOverloadFailed:
Douglas Gregor20093b42009-12-09 23:02:17 +00006394 switch (FailedOverloadResult) {
6395 case OR_Ambiguous:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006396 if (Failure == FK_UserConversionOverloadFailed)
6397 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6398 << Args[0]->getType() << DestType
6399 << Args[0]->getSourceRange();
6400 else
6401 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6402 << DestType << Args[0]->getType()
6403 << Args[0]->getSourceRange();
6404
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006405 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006406 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006407
Douglas Gregor20093b42009-12-09 23:02:17 +00006408 case OR_No_Viable_Function:
Larisse Voufo288f76a2013-06-27 03:36:30 +00006409 if (!S.RequireCompleteType(Kind.getLocation(),
Larisse Voufo7419d012013-06-27 01:50:25 +00006410 DestType.getNonReferenceType(),
6411 diag::err_typecheck_nonviable_condition_incomplete,
6412 Args[0]->getType(), Args[0]->getSourceRange()))
6413 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6414 << Args[0]->getType() << Args[0]->getSourceRange()
6415 << DestType.getNonReferenceType();
6416
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006417 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006418 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006419
Douglas Gregor20093b42009-12-09 23:02:17 +00006420 case OR_Deleted: {
6421 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6422 << Args[0]->getType() << DestType.getNonReferenceType()
6423 << Args[0]->getSourceRange();
6424 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006425 OverloadingResult Ovl
Douglas Gregor8fcc5162010-09-12 08:07:23 +00006426 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6427 true);
Douglas Gregor20093b42009-12-09 23:02:17 +00006428 if (Ovl == OR_Deleted) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00006429 S.NoteDeletedFunction(Best->Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00006430 } else {
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006431 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregor20093b42009-12-09 23:02:17 +00006432 }
6433 break;
6434 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006435
Douglas Gregor20093b42009-12-09 23:02:17 +00006436 case OR_Success:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006437 llvm_unreachable("Conversion did not fail!");
Douglas Gregor20093b42009-12-09 23:02:17 +00006438 }
6439 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006440
Douglas Gregor20093b42009-12-09 23:02:17 +00006441 case FK_NonConstLValueReferenceBindingToTemporary:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006442 if (isa<InitListExpr>(Args[0])) {
6443 S.Diag(Kind.getLocation(),
6444 diag::err_lvalue_reference_bind_to_initlist)
6445 << DestType.getNonReferenceType().isVolatileQualified()
6446 << DestType.getNonReferenceType()
6447 << Args[0]->getSourceRange();
6448 break;
6449 }
6450 // Intentional fallthrough
6451
Douglas Gregor20093b42009-12-09 23:02:17 +00006452 case FK_NonConstLValueReferenceBindingToUnrelated:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006453 S.Diag(Kind.getLocation(),
Douglas Gregor20093b42009-12-09 23:02:17 +00006454 Failure == FK_NonConstLValueReferenceBindingToTemporary
6455 ? diag::err_lvalue_reference_bind_to_temporary
6456 : diag::err_lvalue_reference_bind_to_unrelated)
Douglas Gregoref06e242010-01-29 19:39:15 +00006457 << DestType.getNonReferenceType().isVolatileQualified()
Douglas Gregor20093b42009-12-09 23:02:17 +00006458 << DestType.getNonReferenceType()
6459 << Args[0]->getType()
6460 << Args[0]->getSourceRange();
6461 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006462
Douglas Gregor20093b42009-12-09 23:02:17 +00006463 case FK_RValueReferenceBindingToLValue:
6464 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
Douglas Gregorfb5d7ef2011-01-21 01:04:33 +00006465 << DestType.getNonReferenceType() << Args[0]->getType()
Douglas Gregor20093b42009-12-09 23:02:17 +00006466 << Args[0]->getSourceRange();
6467 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006468
Douglas Gregor20093b42009-12-09 23:02:17 +00006469 case FK_ReferenceInitDropsQualifiers:
6470 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
6471 << DestType.getNonReferenceType()
6472 << Args[0]->getType()
6473 << Args[0]->getSourceRange();
6474 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006475
Douglas Gregor20093b42009-12-09 23:02:17 +00006476 case FK_ReferenceInitFailed:
6477 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
6478 << DestType.getNonReferenceType()
John McCall7eb0a9e2010-11-24 05:12:34 +00006479 << Args[0]->isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00006480 << Args[0]->getType()
6481 << Args[0]->getSourceRange();
John McCall7cca8212013-03-19 07:04:25 +00006482 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00006483 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006484
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006485 case FK_ConversionFailed: {
6486 QualType FromType = Args[0]->getType();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006487 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006488 << (int)Entity.getKind()
Douglas Gregor20093b42009-12-09 23:02:17 +00006489 << DestType
John McCall7eb0a9e2010-11-24 05:12:34 +00006490 << Args[0]->isLValue()
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006491 << FromType
Douglas Gregor20093b42009-12-09 23:02:17 +00006492 << Args[0]->getSourceRange();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006493 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
6494 S.Diag(Kind.getLocation(), PDiag);
John McCall7cca8212013-03-19 07:04:25 +00006495 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregord87b61f2009-12-10 17:56:55 +00006496 break;
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006497 }
John Wiegley429bb272011-04-08 18:41:53 +00006498
6499 case FK_ConversionFromPropertyFailed:
6500 // No-op. This error has already been reported.
6501 break;
6502
Douglas Gregord87b61f2009-12-10 17:56:55 +00006503 case FK_TooManyInitsForScalar: {
Douglas Gregor99a2e602009-12-16 01:38:02 +00006504 SourceRange R;
6505
6506 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
Douglas Gregor19311e72010-09-08 21:40:08 +00006507 R = SourceRange(InitList->getInit(0)->getLocEnd(),
Douglas Gregor99a2e602009-12-16 01:38:02 +00006508 InitList->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006509 else
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006510 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
Douglas Gregord87b61f2009-12-10 17:56:55 +00006511
Douglas Gregor19311e72010-09-08 21:40:08 +00006512 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin()));
6513 if (Kind.isCStyleOrFunctionalCast())
6514 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
6515 << R;
6516 else
6517 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
6518 << /*scalar=*/2 << R;
Douglas Gregord87b61f2009-12-10 17:56:55 +00006519 break;
6520 }
6521
6522 case FK_ReferenceBindingToInitList:
6523 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
6524 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
6525 break;
6526
6527 case FK_InitListBadDestinationType:
6528 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
6529 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
6530 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006531
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006532 case FK_ListConstructorOverloadFailed:
Douglas Gregor51c56d62009-12-14 20:49:26 +00006533 case FK_ConstructorOverloadFailed: {
6534 SourceRange ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006535 if (Args.size())
6536 ArgsRange = SourceRange(Args.front()->getLocStart(),
6537 Args.back()->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006538
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006539 if (Failure == FK_ListConstructorOverloadFailed) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006540 assert(Args.size() == 1 && "List construction from other than 1 argument.");
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006541 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006542 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006543 }
6544
Douglas Gregor51c56d62009-12-14 20:49:26 +00006545 // FIXME: Using "DestType" for the entity we're printing is probably
6546 // bad.
6547 switch (FailedOverloadResult) {
6548 case OR_Ambiguous:
6549 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
6550 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006551 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006552 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006553
Douglas Gregor51c56d62009-12-14 20:49:26 +00006554 case OR_No_Viable_Function:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006555 if (Kind.getKind() == InitializationKind::IK_Default &&
6556 (Entity.getKind() == InitializedEntity::EK_Base ||
6557 Entity.getKind() == InitializedEntity::EK_Member) &&
6558 isa<CXXConstructorDecl>(S.CurContext)) {
6559 // This is implicit default initialization of a member or
6560 // base within a constructor. If no viable function was
6561 // found, notify the user that she needs to explicitly
6562 // initialize this base/member.
6563 CXXConstructorDecl *Constructor
6564 = cast<CXXConstructorDecl>(S.CurContext);
6565 if (Entity.getKind() == InitializedEntity::EK_Base) {
6566 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006567 << (Constructor->getInheritedConstructor() ? 2 :
6568 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006569 << S.Context.getTypeDeclType(Constructor->getParent())
6570 << /*base=*/0
6571 << Entity.getType();
6572
6573 RecordDecl *BaseDecl
6574 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
6575 ->getDecl();
6576 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
6577 << S.Context.getTagDeclType(BaseDecl);
6578 } else {
6579 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006580 << (Constructor->getInheritedConstructor() ? 2 :
6581 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006582 << S.Context.getTypeDeclType(Constructor->getParent())
6583 << /*member=*/1
6584 << Entity.getName();
6585 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
6586
6587 if (const RecordType *Record
6588 = Entity.getType()->getAs<RecordType>())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006589 S.Diag(Record->getDecl()->getLocation(),
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006590 diag::note_previous_decl)
6591 << S.Context.getTagDeclType(Record->getDecl());
6592 }
6593 break;
6594 }
6595
Douglas Gregor51c56d62009-12-14 20:49:26 +00006596 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
6597 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006598 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006599 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006600
Douglas Gregor51c56d62009-12-14 20:49:26 +00006601 case OR_Deleted: {
Douglas Gregor51c56d62009-12-14 20:49:26 +00006602 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006603 OverloadingResult Ovl
6604 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Douglas Gregore4e68d42012-02-15 19:33:52 +00006605 if (Ovl != OR_Deleted) {
6606 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6607 << true << DestType << ArgsRange;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006608 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregore4e68d42012-02-15 19:33:52 +00006609 break;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006610 }
Douglas Gregore4e68d42012-02-15 19:33:52 +00006611
6612 // If this is a defaulted or implicitly-declared function, then
6613 // it was implicitly deleted. Make it clear that the deletion was
6614 // implicit.
Richard Smith6c4c36c2012-03-30 20:53:28 +00006615 if (S.isImplicitlyDeleted(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006616 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
Richard Smith6c4c36c2012-03-30 20:53:28 +00006617 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006618 << DestType << ArgsRange;
Richard Smith6c4c36c2012-03-30 20:53:28 +00006619 else
6620 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6621 << true << DestType << ArgsRange;
6622
6623 S.NoteDeletedFunction(Best->Function);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006624 break;
6625 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006626
Douglas Gregor51c56d62009-12-14 20:49:26 +00006627 case OR_Success:
6628 llvm_unreachable("Conversion did not fail!");
Douglas Gregor51c56d62009-12-14 20:49:26 +00006629 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00006630 }
David Blaikie9fdefb32012-01-17 08:24:58 +00006631 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006632
Douglas Gregor99a2e602009-12-16 01:38:02 +00006633 case FK_DefaultInitOfConst:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006634 if (Entity.getKind() == InitializedEntity::EK_Member &&
6635 isa<CXXConstructorDecl>(S.CurContext)) {
6636 // This is implicit default-initialization of a const member in
6637 // a constructor. Complain that it needs to be explicitly
6638 // initialized.
6639 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
6640 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006641 << (Constructor->getInheritedConstructor() ? 2 :
6642 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006643 << S.Context.getTypeDeclType(Constructor->getParent())
6644 << /*const=*/1
6645 << Entity.getName();
6646 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
6647 << Entity.getName();
6648 } else {
6649 S.Diag(Kind.getLocation(), diag::err_default_init_const)
6650 << DestType << (bool)DestType->getAs<RecordType>();
6651 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00006652 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006653
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006654 case FK_Incomplete:
Douglas Gregor69a30b82012-04-10 20:43:46 +00006655 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006656 diag::err_init_incomplete_type);
6657 break;
6658
Sebastian Redl14b0c192011-09-24 17:48:00 +00006659 case FK_ListInitializationFailed: {
6660 // Run the init list checker again to emit diagnostics.
Bill Wendling2ca3db42013-11-22 00:01:44 +00006661 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6662 diagnoseListInit(S, Entity, InitList);
Sebastian Redl14b0c192011-09-24 17:48:00 +00006663 break;
6664 }
John McCall5acb0c92011-10-17 18:40:02 +00006665
6666 case FK_PlaceholderType: {
6667 // FIXME: Already diagnosed!
6668 break;
6669 }
Sebastian Redl2b916b82012-01-17 22:49:42 +00006670
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006671 case FK_ExplicitConstructor: {
6672 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
6673 << Args[0]->getSourceRange();
6674 OverloadCandidateSet::iterator Best;
6675 OverloadingResult Ovl
6676 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Matt Beaumont-Gaye7d0bbf2012-04-02 19:05:35 +00006677 (void)Ovl;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006678 assert(Ovl == OR_Success && "Inconsistent overload resolution");
6679 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
6680 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
6681 break;
6682 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006683 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006684
Douglas Gregora41a8c52010-04-22 00:20:18 +00006685 PrintInitLocationNote(S, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00006686 return true;
6687}
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006688
Chris Lattner5f9e2722011-07-23 10:55:15 +00006689void InitializationSequence::dump(raw_ostream &OS) const {
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006690 switch (SequenceKind) {
6691 case FailedSequence: {
6692 OS << "Failed sequence: ";
6693 switch (Failure) {
6694 case FK_TooManyInitsForReference:
6695 OS << "too many initializers for reference";
6696 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006697
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006698 case FK_ArrayNeedsInitList:
6699 OS << "array requires initializer list";
6700 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006701
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006702 case FK_ArrayNeedsInitListOrStringLiteral:
6703 OS << "array requires initializer list or string literal";
6704 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006705
Hans Wennborg0ff50742013-05-15 11:03:04 +00006706 case FK_ArrayNeedsInitListOrWideStringLiteral:
6707 OS << "array requires initializer list or wide string literal";
6708 break;
6709
6710 case FK_NarrowStringIntoWideCharArray:
6711 OS << "narrow string into wide char array";
6712 break;
6713
6714 case FK_WideStringIntoCharArray:
6715 OS << "wide string into char array";
6716 break;
6717
6718 case FK_IncompatWideStringIntoWideChar:
6719 OS << "incompatible wide string into wide char array";
6720 break;
6721
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006722 case FK_ArrayTypeMismatch:
6723 OS << "array type mismatch";
6724 break;
6725
6726 case FK_NonConstantArrayInit:
6727 OS << "non-constant array initializer";
6728 break;
6729
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006730 case FK_AddressOfOverloadFailed:
6731 OS << "address of overloaded function failed";
6732 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006733
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006734 case FK_ReferenceInitOverloadFailed:
6735 OS << "overload resolution for reference initialization failed";
6736 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006737
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006738 case FK_NonConstLValueReferenceBindingToTemporary:
6739 OS << "non-const lvalue reference bound to temporary";
6740 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006741
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006742 case FK_NonConstLValueReferenceBindingToUnrelated:
6743 OS << "non-const lvalue reference bound to unrelated type";
6744 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006745
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006746 case FK_RValueReferenceBindingToLValue:
6747 OS << "rvalue reference bound to an lvalue";
6748 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006749
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006750 case FK_ReferenceInitDropsQualifiers:
6751 OS << "reference initialization drops qualifiers";
6752 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006753
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006754 case FK_ReferenceInitFailed:
6755 OS << "reference initialization failed";
6756 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006757
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006758 case FK_ConversionFailed:
6759 OS << "conversion failed";
6760 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006761
John Wiegley429bb272011-04-08 18:41:53 +00006762 case FK_ConversionFromPropertyFailed:
6763 OS << "conversion from property failed";
6764 break;
6765
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006766 case FK_TooManyInitsForScalar:
6767 OS << "too many initializers for scalar";
6768 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006769
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006770 case FK_ReferenceBindingToInitList:
6771 OS << "referencing binding to initializer list";
6772 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006773
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006774 case FK_InitListBadDestinationType:
6775 OS << "initializer list for non-aggregate, non-scalar type";
6776 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006777
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006778 case FK_UserConversionOverloadFailed:
6779 OS << "overloading failed for user-defined conversion";
6780 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006781
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006782 case FK_ConstructorOverloadFailed:
6783 OS << "constructor overloading failed";
6784 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006785
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006786 case FK_DefaultInitOfConst:
6787 OS << "default initialization of a const variable";
6788 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006789
Douglas Gregor72a43bb2010-05-20 22:12:02 +00006790 case FK_Incomplete:
6791 OS << "initialization of incomplete type";
6792 break;
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006793
6794 case FK_ListInitializationFailed:
Sebastian Redl14b0c192011-09-24 17:48:00 +00006795 OS << "list initialization checker failure";
John McCall5acb0c92011-10-17 18:40:02 +00006796 break;
6797
John McCall73076432012-01-05 00:13:19 +00006798 case FK_VariableLengthArrayHasInitializer:
6799 OS << "variable length array has an initializer";
6800 break;
6801
John McCall5acb0c92011-10-17 18:40:02 +00006802 case FK_PlaceholderType:
6803 OS << "initializer expression isn't contextually valid";
6804 break;
Nick Lewyckyb0c6c332011-12-22 20:21:32 +00006805
6806 case FK_ListConstructorOverloadFailed:
6807 OS << "list constructor overloading failed";
6808 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006809
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006810 case FK_ExplicitConstructor:
6811 OS << "list copy initialization chose explicit constructor";
6812 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006813 }
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006814 OS << '\n';
6815 return;
6816 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006817
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006818 case DependentSequence:
Sebastian Redl7491c492011-06-05 13:59:11 +00006819 OS << "Dependent sequence\n";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006820 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006821
Sebastian Redl7491c492011-06-05 13:59:11 +00006822 case NormalSequence:
6823 OS << "Normal sequence: ";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006824 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006825 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006826
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006827 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6828 if (S != step_begin()) {
6829 OS << " -> ";
6830 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006831
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006832 switch (S->Kind) {
6833 case SK_ResolveAddressOfOverloadedFunction:
6834 OS << "resolve address of overloaded function";
6835 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006836
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006837 case SK_CastDerivedToBaseRValue:
6838 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6839 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006840
Sebastian Redl906082e2010-07-20 04:20:21 +00006841 case SK_CastDerivedToBaseXValue:
6842 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
6843 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006844
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006845 case SK_CastDerivedToBaseLValue:
6846 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
6847 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006848
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006849 case SK_BindReference:
6850 OS << "bind reference to lvalue";
6851 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006852
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006853 case SK_BindReferenceToTemporary:
6854 OS << "bind reference to a temporary";
6855 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006856
Douglas Gregor523d46a2010-04-18 07:40:54 +00006857 case SK_ExtraneousCopyToTemporary:
6858 OS << "extraneous C++03 copy to temporary";
6859 break;
6860
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006861 case SK_UserConversion:
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006862 OS << "user-defined conversion via " << *S->Function.Function;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006863 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006864
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006865 case SK_QualificationConversionRValue:
6866 OS << "qualification conversion (rvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006867 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006868
Sebastian Redl906082e2010-07-20 04:20:21 +00006869 case SK_QualificationConversionXValue:
6870 OS << "qualification conversion (xvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006871 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006872
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006873 case SK_QualificationConversionLValue:
6874 OS << "qualification conversion (lvalue)";
6875 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006876
Jordan Rose1fd1e282013-04-11 00:58:58 +00006877 case SK_LValueToRValue:
6878 OS << "load (lvalue to rvalue)";
6879 break;
6880
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006881 case SK_ConversionSequence:
6882 OS << "implicit conversion sequence (";
Douglas Gregor2f8b0cc2013-11-08 02:16:10 +00006883 S->ICS->dump(); // FIXME: use OS
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006884 OS << ")";
6885 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006886
Richard Smith13b228d2013-09-21 21:19:19 +00006887 case SK_ConversionSequenceNoNarrowing:
6888 OS << "implicit conversion sequence with narrowing prohibited (";
Douglas Gregor2f8b0cc2013-11-08 02:16:10 +00006889 S->ICS->dump(); // FIXME: use OS
Richard Smith13b228d2013-09-21 21:19:19 +00006890 OS << ")";
6891 break;
6892
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006893 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006894 OS << "list aggregate initialization";
6895 break;
6896
6897 case SK_ListConstructorCall:
6898 OS << "list initialization via constructor";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006899 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006900
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006901 case SK_UnwrapInitList:
6902 OS << "unwrap reference initializer list";
6903 break;
6904
6905 case SK_RewrapInitList:
6906 OS << "rewrap reference initializer list";
6907 break;
6908
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006909 case SK_ConstructorInitialization:
6910 OS << "constructor initialization";
6911 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006912
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006913 case SK_ZeroInitialization:
6914 OS << "zero initialization";
6915 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006916
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006917 case SK_CAssignment:
6918 OS << "C assignment";
6919 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006920
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006921 case SK_StringInit:
6922 OS << "string initialization";
6923 break;
Douglas Gregor569c3162010-08-07 11:51:51 +00006924
6925 case SK_ObjCObjectConversion:
6926 OS << "Objective-C object conversion";
6927 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006928
6929 case SK_ArrayInit:
6930 OS << "array initialization";
6931 break;
John McCallf85e1932011-06-15 23:02:42 +00006932
Richard Smith0f163e92012-02-15 22:38:09 +00006933 case SK_ParenthesizedArrayInit:
6934 OS << "parenthesized array initialization";
6935 break;
6936
John McCallf85e1932011-06-15 23:02:42 +00006937 case SK_PassByIndirectCopyRestore:
6938 OS << "pass by indirect copy and restore";
6939 break;
6940
6941 case SK_PassByIndirectRestore:
6942 OS << "pass by indirect restore";
6943 break;
6944
6945 case SK_ProduceObjCObject:
6946 OS << "Objective-C object retension";
6947 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006948
6949 case SK_StdInitializerList:
6950 OS << "std::initializer_list from initializer list";
6951 break;
Guy Benyeie6b9d802013-01-20 12:31:11 +00006952
Guy Benyei21f18c42013-02-07 10:55:47 +00006953 case SK_OCLSamplerInit:
6954 OS << "OpenCL sampler_t from integer constant";
6955 break;
6956
Guy Benyeie6b9d802013-01-20 12:31:11 +00006957 case SK_OCLZeroEvent:
6958 OS << "OpenCL event_t from zero";
6959 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006960 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006961
6962 OS << " [" << S->Type.getAsString() << ']';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006963 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006964
6965 OS << '\n';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006966}
6967
6968void InitializationSequence::dump() const {
6969 dump(llvm::errs());
6970}
6971
Richard Smith13b228d2013-09-21 21:19:19 +00006972static void DiagnoseNarrowingInInitList(Sema &S,
6973 const ImplicitConversionSequence &ICS,
6974 QualType PreNarrowingType,
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006975 QualType EntityType,
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006976 const Expr *PostInit) {
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006977 const StandardConversionSequence *SCS = 0;
6978 switch (ICS.getKind()) {
6979 case ImplicitConversionSequence::StandardConversion:
6980 SCS = &ICS.Standard;
6981 break;
6982 case ImplicitConversionSequence::UserDefinedConversion:
6983 SCS = &ICS.UserDefined.After;
6984 break;
6985 case ImplicitConversionSequence::AmbiguousConversion:
6986 case ImplicitConversionSequence::EllipsisConversion:
6987 case ImplicitConversionSequence::BadConversion:
6988 return;
6989 }
6990
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006991 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
6992 APValue ConstantValue;
Richard Smithf6028062012-03-23 23:55:39 +00006993 QualType ConstantType;
6994 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
6995 ConstantType)) {
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006996 case NK_Not_Narrowing:
6997 // No narrowing occurred.
6998 return;
6999
7000 case NK_Type_Narrowing:
7001 // This was a floating-to-integer conversion, which is always considered a
7002 // narrowing conversion even if the value is a constant and can be
7003 // represented exactly as an integer.
7004 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007005 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7006 ? diag::warn_init_list_type_narrowing
7007 : diag::ext_init_list_type_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007008 << PostInit->getSourceRange()
7009 << PreNarrowingType.getLocalUnqualifiedType()
7010 << EntityType.getLocalUnqualifiedType();
7011 break;
7012
7013 case NK_Constant_Narrowing:
7014 // A constant value was narrowed.
7015 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007016 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7017 ? diag::warn_init_list_constant_narrowing
7018 : diag::ext_init_list_constant_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007019 << PostInit->getSourceRange()
Richard Smithf6028062012-03-23 23:55:39 +00007020 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
Jeffrey Yasskin99061492011-08-29 15:59:37 +00007021 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007022 break;
7023
7024 case NK_Variable_Narrowing:
7025 // A variable's value may have been narrowed.
7026 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007027 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7028 ? diag::warn_init_list_variable_narrowing
7029 : diag::ext_init_list_variable_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007030 << PostInit->getSourceRange()
7031 << PreNarrowingType.getLocalUnqualifiedType()
Jeffrey Yasskin99061492011-08-29 15:59:37 +00007032 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007033 break;
7034 }
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007035
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00007036 SmallString<128> StaticCast;
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007037 llvm::raw_svector_ostream OS(StaticCast);
7038 OS << "static_cast<";
7039 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7040 // It's important to use the typedef's name if there is one so that the
7041 // fixit doesn't break code using types like int64_t.
7042 //
7043 // FIXME: This will break if the typedef requires qualification. But
7044 // getQualifiedNameAsString() includes non-machine-parsable components.
Benjamin Kramerb8989f22011-10-14 18:45:37 +00007045 OS << *TT->getDecl();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007046 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
David Blaikie4e4d0842012-03-11 07:00:24 +00007047 OS << BT->getName(S.getLangOpts());
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007048 else {
7049 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7050 // with a broken cast.
7051 return;
7052 }
7053 OS << ">(";
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007054 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override)
7055 << PostInit->getSourceRange()
7056 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007057 << FixItHint::CreateInsertion(
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007058 S.getPreprocessor().getLocForEndOfToken(PostInit->getLocEnd()), ")");
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007059}
7060
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007061//===----------------------------------------------------------------------===//
7062// Initialization helper functions
7063//===----------------------------------------------------------------------===//
Sean Hunt2be7e902011-05-12 22:46:29 +00007064bool
7065Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7066 ExprResult Init) {
7067 if (Init.isInvalid())
7068 return false;
7069
7070 Expr *InitE = Init.get();
7071 assert(InitE && "No initialization expression");
7072
Douglas Gregor3c394c52012-07-31 22:15:04 +00007073 InitializationKind Kind
7074 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00007075 InitializationSequence Seq(*this, Entity, Kind, InitE);
Sebastian Redl383616c2011-06-05 12:23:28 +00007076 return !Seq.Failed();
Sean Hunt2be7e902011-05-12 22:46:29 +00007077}
7078
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00007079ExprResult
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007080Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7081 SourceLocation EqualLoc,
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007082 ExprResult Init,
Douglas Gregored878af2012-02-24 23:56:31 +00007083 bool TopLevelOfInitList,
7084 bool AllowExplicit) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007085 if (Init.isInvalid())
7086 return ExprError();
7087
John McCall15d7d122010-11-11 03:21:53 +00007088 Expr *InitE = Init.get();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007089 assert(InitE && "No initialization expression?");
7090
7091 if (EqualLoc.isInvalid())
7092 EqualLoc = InitE->getLocStart();
7093
7094 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
Douglas Gregored878af2012-02-24 23:56:31 +00007095 EqualLoc,
7096 AllowExplicit);
Richard Smith13b228d2013-09-21 21:19:19 +00007097 InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007098 Init.release();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007099
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00007100 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007101
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007102 return Result;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007103}