blob: a16960213eb37f75517925bdb157685063d1649f [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/Sema/Designator.h"
21#include "clang/Sema/Lookup.h"
22#include "clang/Sema/SemaInternal.h"
Sebastian Redl2b916b82012-01-17 22:49:42 +000023#include "llvm/ADT/APInt.h"
Benjamin Kramer8fe83e12012-02-04 13:45:25 +000024#include "llvm/ADT/SmallString.h"
Douglas Gregor20093b42009-12-09 23:02:17 +000025#include "llvm/Support/ErrorHandling.h"
Jeffrey Yasskin19159132011-07-26 23:20:30 +000026#include "llvm/Support/raw_ostream.h"
Douglas Gregorc34ee5e2009-01-29 00:45:39 +000027#include <map>
Douglas Gregor05c13a32009-01-22 00:58:24 +000028using namespace clang;
Steve Naroff0cca7492008-05-01 22:18:59 +000029
Chris Lattnerdd8e0062009-02-24 22:27:37 +000030//===----------------------------------------------------------------------===//
31// Sema Initialization Checking
32//===----------------------------------------------------------------------===//
33
Hans Wennborg0ff50742013-05-15 11:03:04 +000034/// \brief Check whether T is compatible with a wide character type (wchar_t,
35/// char16_t or char32_t).
36static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
37 if (Context.typesAreCompatible(Context.getWideCharType(), T))
38 return true;
39 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
40 return Context.typesAreCompatible(Context.Char16Ty, T) ||
41 Context.typesAreCompatible(Context.Char32Ty, T);
42 }
43 return false;
44}
45
46enum StringInitFailureKind {
47 SIF_None,
48 SIF_NarrowStringIntoWideChar,
49 SIF_WideStringIntoChar,
50 SIF_IncompatWideStringIntoWideChar,
51 SIF_Other
52};
53
54/// \brief Check whether the array of type AT can be initialized by the Init
55/// expression by means of string initialization. Returns SIF_None if so,
56/// otherwise returns a StringInitFailureKind that describes why the
57/// initialization would not work.
58static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
59 ASTContext &Context) {
Eli Friedman8718a6a2009-05-29 18:22:49 +000060 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
Hans Wennborg0ff50742013-05-15 11:03:04 +000061 return SIF_Other;
Eli Friedman8718a6a2009-05-29 18:22:49 +000062
Chris Lattner8879e3b2009-02-26 23:26:43 +000063 // See if this is a string literal or @encode.
64 Init = Init->IgnoreParens();
Mike Stump1eb44332009-09-09 15:08:12 +000065
Chris Lattner8879e3b2009-02-26 23:26:43 +000066 // Handle @encode, which is a narrow string.
67 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
Hans Wennborg0ff50742013-05-15 11:03:04 +000068 return SIF_None;
Chris Lattner8879e3b2009-02-26 23:26:43 +000069
70 // Otherwise we can only handle string literals.
71 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
Stephen Hines6bcf27b2014-05-29 04:14:42 -070072 if (!SL)
Hans Wennborg0ff50742013-05-15 11:03:04 +000073 return SIF_Other;
Eli Friedmanbb6415c2009-05-31 10:54:53 +000074
Hans Wennborg0ff50742013-05-15 11:03:04 +000075 const QualType ElemTy =
76 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
Douglas Gregor5cee1192011-07-27 05:40:30 +000077
78 switch (SL->getKind()) {
79 case StringLiteral::Ascii:
80 case StringLiteral::UTF8:
81 // char array can be initialized with a narrow string.
82 // Only allow char x[] = "foo"; not char x[] = L"foo";
Hans Wennborg0ff50742013-05-15 11:03:04 +000083 if (ElemTy->isCharType())
84 return SIF_None;
85 if (IsWideCharCompatible(ElemTy, Context))
86 return SIF_NarrowStringIntoWideChar;
87 return SIF_Other;
88 // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
89 // "An array with element type compatible with a qualified or unqualified
90 // version of wchar_t, char16_t, or char32_t may be initialized by a wide
91 // string literal with the corresponding encoding prefix (L, u, or U,
92 // respectively), optionally enclosed in braces.
Douglas Gregor5cee1192011-07-27 05:40:30 +000093 case StringLiteral::UTF16:
Hans Wennborg0ff50742013-05-15 11:03:04 +000094 if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
95 return SIF_None;
96 if (ElemTy->isCharType())
97 return SIF_WideStringIntoChar;
98 if (IsWideCharCompatible(ElemTy, Context))
99 return SIF_IncompatWideStringIntoWideChar;
100 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000101 case StringLiteral::UTF32:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000102 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
103 return SIF_None;
104 if (ElemTy->isCharType())
105 return SIF_WideStringIntoChar;
106 if (IsWideCharCompatible(ElemTy, Context))
107 return SIF_IncompatWideStringIntoWideChar;
108 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000109 case StringLiteral::Wide:
Hans Wennborg0ff50742013-05-15 11:03:04 +0000110 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
111 return SIF_None;
112 if (ElemTy->isCharType())
113 return SIF_WideStringIntoChar;
114 if (IsWideCharCompatible(ElemTy, Context))
115 return SIF_IncompatWideStringIntoWideChar;
116 return SIF_Other;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000117 }
Mike Stump1eb44332009-09-09 15:08:12 +0000118
Douglas Gregor5cee1192011-07-27 05:40:30 +0000119 llvm_unreachable("missed a StringLiteral kind?");
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000120}
121
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000122static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
123 ASTContext &Context) {
John McCallce6c9b72011-02-21 07:22:22 +0000124 const ArrayType *arrayType = Context.getAsArrayType(declType);
Hans Wennborg0ff50742013-05-15 11:03:04 +0000125 if (!arrayType)
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000126 return SIF_Other;
127 return IsStringInit(init, arrayType, Context);
John McCallce6c9b72011-02-21 07:22:22 +0000128}
129
Richard Smith30ae1ed2013-05-05 16:40:13 +0000130/// Update the type of a string literal, including any surrounding parentheses,
131/// to match the type of the object which it is initializing.
132static void updateStringLiteralType(Expr *E, QualType Ty) {
Richard Smith27f9cf32013-05-06 00:35:47 +0000133 while (true) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000134 E->setType(Ty);
Richard Smith27f9cf32013-05-06 00:35:47 +0000135 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
136 break;
137 else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
138 E = PE->getSubExpr();
139 else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
140 E = UO->getSubExpr();
141 else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
142 E = GSE->getResultExpr();
143 else
144 llvm_unreachable("unexpected expr in string literal init");
Richard Smith30ae1ed2013-05-05 16:40:13 +0000145 }
Richard Smith30ae1ed2013-05-05 16:40:13 +0000146}
147
John McCallfef8b342011-02-21 07:57:55 +0000148static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
149 Sema &S) {
Chris Lattner79e079d2009-02-24 23:10:27 +0000150 // Get the length of the string as parsed.
151 uint64_t StrLength =
152 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
153
Mike Stump1eb44332009-09-09 15:08:12 +0000154
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000155 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
Mike Stump1eb44332009-09-09 15:08:12 +0000156 // C99 6.7.8p14. We have an array of character type with unknown size
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000157 // being initialized to a string literal.
Benjamin Kramer65263b42012-08-04 17:00:46 +0000158 llvm::APInt ConstVal(32, StrLength);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000159 // Return a new array type (C99 6.7.8p22).
John McCall46a617a2009-10-16 00:14:28 +0000160 DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
161 ConstVal,
162 ArrayType::Normal, 0);
Richard Smith30ae1ed2013-05-05 16:40:13 +0000163 updateStringLiteralType(Str, DeclT);
Chris Lattner19da8cd2009-02-24 23:01:39 +0000164 return;
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000165 }
Mike Stump1eb44332009-09-09 15:08:12 +0000166
Eli Friedman8718a6a2009-05-29 18:22:49 +0000167 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
Mike Stump1eb44332009-09-09 15:08:12 +0000168
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000169 // We have an array of character type with known size. However,
Eli Friedman8718a6a2009-05-29 18:22:49 +0000170 // the size may be smaller or larger than the string we are initializing.
171 // FIXME: Avoid truncation for 64-bit length strings.
David Blaikie4e4d0842012-03-11 07:00:24 +0000172 if (S.getLangOpts().CPlusPlus) {
Richard Smith30ae1ed2013-05-05 16:40:13 +0000173 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
Anders Carlssonb8fc45f2011-04-14 00:41:11 +0000174 // For Pascal strings it's OK to strip off the terminating null character,
175 // so the example below is valid:
176 //
177 // unsigned char a[2] = "\pa";
178 if (SL->isPascal())
179 StrLength--;
180 }
181
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000182 // [dcl.init.string]p2
183 if (StrLength > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000184 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000185 diag::err_initializer_string_for_char_array_too_long)
186 << Str->getSourceRange();
187 } else {
188 // C99 6.7.8p14.
189 if (StrLength-1 > CAT->getSize().getZExtValue())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000190 S.Diag(Str->getLocStart(),
Eli Friedmanbc34b1d2011-04-11 00:23:45 +0000191 diag::warn_initializer_string_for_char_array_too_long)
192 << Str->getSourceRange();
193 }
Mike Stump1eb44332009-09-09 15:08:12 +0000194
Eli Friedman8718a6a2009-05-29 18:22:49 +0000195 // Set the type to the actual size that we are initializing. If we have
196 // something like:
197 // char x[1] = "foo";
198 // then this will set the string literal's type to char[1].
Richard Smith30ae1ed2013-05-05 16:40:13 +0000199 updateStringLiteralType(Str, DeclT);
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000200}
201
Chris Lattnerdd8e0062009-02-24 22:27:37 +0000202//===----------------------------------------------------------------------===//
203// Semantic checking for initializer lists.
204//===----------------------------------------------------------------------===//
205
Douglas Gregor9e80f722009-01-29 01:05:33 +0000206/// @brief Semantic checking for initializer lists.
207///
208/// The InitListChecker class contains a set of routines that each
209/// handle the initialization of a certain kind of entity, e.g.,
210/// arrays, vectors, struct/union types, scalars, etc. The
211/// InitListChecker itself performs a recursive walk of the subobject
212/// structure of the type to be initialized, while stepping through
213/// the initializer list one element at a time. The IList and Index
214/// parameters to each of the Check* routines contain the active
215/// (syntactic) initializer list and the index into that initializer
216/// list that represents the current initializer. Each routine is
217/// responsible for moving that Index forward as it consumes elements.
218///
219/// Each Check* routine also has a StructuredList/StructuredIndex
Abramo Bagnara63e7d252011-01-27 19:55:10 +0000220/// arguments, which contains the current "structured" (semantic)
Douglas Gregor9e80f722009-01-29 01:05:33 +0000221/// initializer list and the index into that initializer list where we
222/// are copying initializers as we map them over to the semantic
223/// list. Once we have completed our recursive walk of the subobject
224/// structure, we will have constructed a full semantic initializer
225/// list.
226///
227/// C99 designators cause changes in the initializer list traversal,
228/// because they make the initialization "jump" into a specific
229/// subobject and then continue the initialization from that
230/// point. CheckDesignatedInitializer() recursively steps into the
231/// designated subobject and manages backing out the recursion to
232/// initialize the subobjects after the one designated.
Chris Lattner8b419b92009-02-24 22:48:58 +0000233namespace {
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000234class InitListChecker {
Chris Lattner08202542009-02-24 22:50:46 +0000235 Sema &SemaRef;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000236 bool hadError;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000237 bool VerifyOnly; // no diagnostics, no structure building
Benjamin Kramera7894162012-02-23 14:48:40 +0000238 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000239 InitListExpr *FullyStructuredList;
Mike Stump1eb44332009-09-09 15:08:12 +0000240
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000241 void CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000242 InitListExpr *ParentIList, QualType T,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000243 unsigned &Index, InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000244 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000245 void CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000246 InitListExpr *IList, QualType &T,
Richard Smithb9bf3122013-09-20 20:10:22 +0000247 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000248 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000249 void CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000250 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000251 bool SubobjectIsDesignatorContext,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000252 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000253 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000254 unsigned &StructuredIndex,
255 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000256 void CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000257 InitListExpr *IList, QualType ElemType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000258 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000259 InitListExpr *StructuredList,
260 unsigned &StructuredIndex);
Eli Friedman0c706c22011-09-19 23:17:44 +0000261 void CheckComplexType(const InitializedEntity &Entity,
262 InitListExpr *IList, QualType DeclType,
263 unsigned &Index,
264 InitListExpr *StructuredList,
265 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000266 void CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000267 InitListExpr *IList, QualType DeclType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000268 unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000269 InitListExpr *StructuredList,
270 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000271 void CheckReferenceType(const InitializedEntity &Entity,
272 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +0000273 unsigned &Index,
274 InitListExpr *StructuredList,
275 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000276 void CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000277 InitListExpr *IList, QualType DeclType, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000278 InitListExpr *StructuredList,
279 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000280 void CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +0000281 InitListExpr *IList, QualType DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000282 RecordDecl::field_iterator Field,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000283 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000284 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000285 unsigned &StructuredIndex,
286 bool TopLevelObject = false);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000287 void CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +0000288 InitListExpr *IList, QualType &DeclType,
Mike Stump1eb44332009-09-09 15:08:12 +0000289 llvm::APSInt elementIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000290 bool SubobjectIsDesignatorContext, unsigned &Index,
Douglas Gregor9e80f722009-01-29 01:05:33 +0000291 InitListExpr *StructuredList,
292 unsigned &StructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000293 bool CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +0000294 InitListExpr *IList, DesignatedInitExpr *DIE,
Douglas Gregor71199712009-04-15 04:56:10 +0000295 unsigned DesigIdx,
Mike Stump1eb44332009-09-09 15:08:12 +0000296 QualType &CurrentObjectType,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000297 RecordDecl::field_iterator *NextField,
298 llvm::APSInt *NextElementIndex,
299 unsigned &Index,
300 InitListExpr *StructuredList,
301 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000302 bool FinishSubobjectInit,
303 bool TopLevelObject);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000304 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
305 QualType CurrentObjectType,
306 InitListExpr *StructuredList,
307 unsigned StructuredIndex,
308 SourceRange InitRange);
Douglas Gregor9e80f722009-01-29 01:05:33 +0000309 void UpdateStructuredListElement(InitListExpr *StructuredList,
310 unsigned &StructuredIndex,
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000311 Expr *expr);
312 int numArrayElements(QualType DeclType);
313 int numStructUnionElements(QualType DeclType);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000314
Douglas Gregord6d37de2009-12-22 00:05:34 +0000315 void FillInValueInitForField(unsigned Init, FieldDecl *Field,
316 const InitializedEntity &ParentEntity,
317 InitListExpr *ILE, bool &RequiresSecondPass);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000318 void FillInValueInitializations(const InitializedEntity &Entity,
319 InitListExpr *ILE, bool &RequiresSecondPass);
Eli Friedmanf40fd6b2011-08-23 22:24:57 +0000320 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
321 Expr *InitExpr, FieldDecl *Field,
322 bool TopLevelObject);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000323 void CheckValueInitializable(const InitializedEntity &Entity);
324
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000325public:
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000326 InitListChecker(Sema &S, const InitializedEntity &Entity,
Richard Smith40cba902013-06-06 11:41:05 +0000327 InitListExpr *IL, QualType &T, bool VerifyOnly);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +0000328 bool HadError() { return hadError; }
329
330 // @brief Retrieves the fully-structured initializer list used for
331 // semantic analysis and code generation.
332 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
333};
Chris Lattner8b419b92009-02-24 22:48:58 +0000334} // end anonymous namespace
Chris Lattner68355a52009-01-29 05:10:57 +0000335
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000336void InitListChecker::CheckValueInitializable(const InitializedEntity &Entity) {
337 assert(VerifyOnly &&
338 "CheckValueInitializable is only inteded for verification mode.");
339
340 SourceLocation Loc;
341 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
342 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000343 InitializationSequence InitSeq(SemaRef, Entity, Kind, None);
Sebastian Redl3ff5c862011-10-16 18:19:20 +0000344 if (InitSeq.Failed())
345 hadError = true;
346}
347
Douglas Gregord6d37de2009-12-22 00:05:34 +0000348void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
349 const InitializedEntity &ParentEntity,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000350 InitListExpr *ILE,
Douglas Gregord6d37de2009-12-22 00:05:34 +0000351 bool &RequiresSecondPass) {
Daniel Dunbar96a00142012-03-09 18:35:03 +0000352 SourceLocation Loc = ILE->getLocStart();
Douglas Gregord6d37de2009-12-22 00:05:34 +0000353 unsigned NumInits = ILE->getNumInits();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000354 InitializedEntity MemberEntity
Douglas Gregord6d37de2009-12-22 00:05:34 +0000355 = InitializedEntity::InitializeMember(Field, &ParentEntity);
356 if (Init >= NumInits || !ILE->getInit(Init)) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000357 // If there's no explicit initializer but we have a default initializer, use
358 // that. This only happens in C++1y, since classes with default
359 // initializers are not aggregates in C++11.
360 if (Field->hasInClassInitializer()) {
361 Expr *DIE = CXXDefaultInitExpr::Create(SemaRef.Context,
362 ILE->getRBraceLoc(), Field);
363 if (Init < NumInits)
364 ILE->setInit(Init, DIE);
365 else {
366 ILE->updateInit(SemaRef.Context, Init, DIE);
367 RequiresSecondPass = true;
368 }
369 return;
370 }
371
Douglas Gregord6d37de2009-12-22 00:05:34 +0000372 // FIXME: We probably don't need to handle references
373 // specially here, since value-initialization of references is
374 // handled in InitializationSequence.
375 if (Field->getType()->isReferenceType()) {
376 // C++ [dcl.init.aggr]p9:
377 // If an incomplete or empty initializer-list leaves a
378 // member of reference type uninitialized, the program is
379 // ill-formed.
380 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
381 << Field->getType()
382 << ILE->getSyntacticForm()->getSourceRange();
383 SemaRef.Diag(Field->getLocation(),
384 diag::note_uninit_reference_member);
385 hadError = true;
386 return;
387 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000388
Douglas Gregord6d37de2009-12-22 00:05:34 +0000389 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
390 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000391 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000392 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000393 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000394 hadError = true;
395 return;
396 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000397
John McCall60d7b3a2010-08-24 06:29:42 +0000398 ExprResult MemberInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000399 = InitSeq.Perform(SemaRef, MemberEntity, Kind, None);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000400 if (MemberInit.isInvalid()) {
401 hadError = true;
402 return;
403 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000404
Douglas Gregord6d37de2009-12-22 00:05:34 +0000405 if (hadError) {
406 // Do nothing
407 } else if (Init < NumInits) {
408 ILE->setInit(Init, MemberInit.takeAs<Expr>());
Sebastian Redl7491c492011-06-05 13:59:11 +0000409 } else if (InitSeq.isConstructorInitialization()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000410 // Value-initialization requires a constructor call, so
411 // extend the initializer list to include the constructor
412 // call and make a note that we'll need to take another pass
413 // through the initializer list.
Ted Kremenek709210f2010-04-13 23:39:13 +0000414 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
Douglas Gregord6d37de2009-12-22 00:05:34 +0000415 RequiresSecondPass = true;
416 }
417 } else if (InitListExpr *InnerILE
418 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000419 FillInValueInitializations(MemberEntity, InnerILE,
420 RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000421}
422
Douglas Gregor4c678342009-01-28 21:54:33 +0000423/// Recursively replaces NULL values within the given initializer list
424/// with expressions that perform value-initialization of the
425/// appropriate type.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000426void
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000427InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
428 InitListExpr *ILE,
429 bool &RequiresSecondPass) {
Mike Stump1eb44332009-09-09 15:08:12 +0000430 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
Douglas Gregor930d8b52009-01-30 22:09:00 +0000431 "Should not have void type");
Daniel Dunbar96a00142012-03-09 18:35:03 +0000432 SourceLocation Loc = ILE->getLocStart();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000433 if (ILE->getSyntacticForm())
Daniel Dunbar96a00142012-03-09 18:35:03 +0000434 Loc = ILE->getSyntacticForm()->getLocStart();
Mike Stump1eb44332009-09-09 15:08:12 +0000435
Ted Kremenek6217b802009-07-29 21:53:49 +0000436 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000437 const RecordDecl *RDecl = RType->getDecl();
438 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000439 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
440 Entity, ILE, RequiresSecondPass);
Richard Smithc3bf52c2013-04-20 22:23:05 +0000441 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
442 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700443 for (auto *Field : RDecl->fields()) {
Richard Smithc3bf52c2013-04-20 22:23:05 +0000444 if (Field->hasInClassInitializer()) {
Stephen Hines651f13c2014-04-23 16:59:28 -0700445 FillInValueInitForField(0, Field, Entity, ILE, RequiresSecondPass);
Richard Smithc3bf52c2013-04-20 22:23:05 +0000446 break;
447 }
448 }
449 } else {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000450 unsigned Init = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -0700451 for (auto *Field : RDecl->fields()) {
Douglas Gregord6d37de2009-12-22 00:05:34 +0000452 if (Field->isUnnamedBitfield())
453 continue;
Douglas Gregor4c678342009-01-28 21:54:33 +0000454
Douglas Gregord6d37de2009-12-22 00:05:34 +0000455 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000456 return;
Douglas Gregord6d37de2009-12-22 00:05:34 +0000457
Stephen Hines651f13c2014-04-23 16:59:28 -0700458 FillInValueInitForField(Init, Field, Entity, ILE, RequiresSecondPass);
Douglas Gregord6d37de2009-12-22 00:05:34 +0000459 if (hadError)
Douglas Gregor87fd7032009-02-02 17:43:21 +0000460 return;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000461
Douglas Gregord6d37de2009-12-22 00:05:34 +0000462 ++Init;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000463
Douglas Gregord6d37de2009-12-22 00:05:34 +0000464 // Only look at the first initialization of a union.
Richard Smithc3bf52c2013-04-20 22:23:05 +0000465 if (RDecl->isUnion())
Douglas Gregord6d37de2009-12-22 00:05:34 +0000466 break;
467 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000468 }
469
470 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000471 }
Douglas Gregor4c678342009-01-28 21:54:33 +0000472
473 QualType ElementType;
Mike Stump1eb44332009-09-09 15:08:12 +0000474
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000475 InitializedEntity ElementEntity = Entity;
Douglas Gregor87fd7032009-02-02 17:43:21 +0000476 unsigned NumInits = ILE->getNumInits();
477 unsigned NumElements = NumInits;
Chris Lattner08202542009-02-24 22:50:46 +0000478 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000479 ElementType = AType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000480 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
481 NumElements = CAType->getSize().getZExtValue();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000482 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000483 0, Entity);
John McCall183700f2009-09-21 23:43:11 +0000484 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
Douglas Gregor4c678342009-01-28 21:54:33 +0000485 ElementType = VType->getElementType();
Douglas Gregor87fd7032009-02-02 17:43:21 +0000486 NumElements = VType->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000487 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000488 0, Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000489 } else
Douglas Gregor4c678342009-01-28 21:54:33 +0000490 ElementType = ILE->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000491
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000492
Douglas Gregor87fd7032009-02-02 17:43:21 +0000493 for (unsigned Init = 0; Init != NumElements; ++Init) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000494 if (hadError)
495 return;
496
Anders Carlssond3d824d2010-01-23 04:34:47 +0000497 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
498 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000499 ElementEntity.setElementIndex(Init);
500
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700501 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000502 if (!InitExpr && !ILE->hasArrayFiller()) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000503 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
504 true);
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000505 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000506 if (!InitSeq) {
Dmitri Gribenko55431692013-05-05 00:41:58 +0000507 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, None);
Douglas Gregor87fd7032009-02-02 17:43:21 +0000508 hadError = true;
509 return;
510 }
511
John McCall60d7b3a2010-08-24 06:29:42 +0000512 ExprResult ElementInit
Dmitri Gribenko62ed8892013-05-05 20:40:26 +0000513 = InitSeq.Perform(SemaRef, ElementEntity, Kind, None);
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000514 if (ElementInit.isInvalid()) {
Douglas Gregor16006c92009-12-16 18:50:27 +0000515 hadError = true;
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000516 return;
517 }
518
519 if (hadError) {
520 // Do nothing
521 } else if (Init < NumInits) {
Argyrios Kyrtzidis3e8dc2a2011-04-21 20:03:38 +0000522 // For arrays, just set the expression used for value-initialization
523 // of the "holes" in the array.
524 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
525 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
526 else
527 ILE->setInit(Init, ElementInit.takeAs<Expr>());
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000528 } else {
529 // For arrays, just set the expression used for value-initialization
530 // of the rest of elements and exit.
531 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
532 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
533 return;
534 }
535
Sebastian Redl7491c492011-06-05 13:59:11 +0000536 if (InitSeq.isConstructorInitialization()) {
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000537 // Value-initialization requires a constructor call, so
538 // extend the initializer list to include the constructor
539 // call and make a note that we'll need to take another pass
540 // through the initializer list.
541 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
542 RequiresSecondPass = true;
543 }
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000544 }
Mike Stumpac5fc7c2009-08-04 21:02:39 +0000545 } else if (InitListExpr *InnerILE
Argyrios Kyrtzidis21f77cd2011-10-21 23:02:22 +0000546 = dyn_cast_or_null<InitListExpr>(InitExpr))
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000547 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
Douglas Gregor4c678342009-01-28 21:54:33 +0000548 }
549}
550
Chris Lattner68355a52009-01-29 05:10:57 +0000551
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000552InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
Sebastian Redl14b0c192011-09-24 17:48:00 +0000553 InitListExpr *IL, QualType &T,
Richard Smith40cba902013-06-06 11:41:05 +0000554 bool VerifyOnly)
555 : SemaRef(S), VerifyOnly(VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000556 hadError = false;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000557
Richard Smithb9bf3122013-09-20 20:10:22 +0000558 FullyStructuredList =
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700559 getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
Richard Smithb9bf3122013-09-20 20:10:22 +0000560 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000561 /*TopLevelObject=*/true);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000562
Sebastian Redl14b0c192011-09-24 17:48:00 +0000563 if (!hadError && !VerifyOnly) {
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000564 bool RequiresSecondPass = false;
565 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
Douglas Gregor16006c92009-12-16 18:50:27 +0000566 if (RequiresSecondPass && !hadError)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000567 FillInValueInitializations(Entity, FullyStructuredList,
Douglas Gregorcb57fb92009-12-16 06:35:08 +0000568 RequiresSecondPass);
569 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000570}
571
572int InitListChecker::numArrayElements(QualType DeclType) {
Eli Friedman638e1442008-05-25 13:22:35 +0000573 // FIXME: use a proper constant
574 int maxElements = 0x7FFFFFFF;
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000575 if (const ConstantArrayType *CAT =
Chris Lattner08202542009-02-24 22:50:46 +0000576 SemaRef.Context.getAsConstantArrayType(DeclType)) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000577 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
578 }
579 return maxElements;
580}
581
582int InitListChecker::numStructUnionElements(QualType DeclType) {
Ted Kremenek6217b802009-07-29 21:53:49 +0000583 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
Douglas Gregor4c678342009-01-28 21:54:33 +0000584 int InitializableMembers = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -0700585 for (const auto *Field : structDecl->fields())
Douglas Gregord61db332011-10-10 17:22:13 +0000586 if (!Field->isUnnamedBitfield())
Douglas Gregor4c678342009-01-28 21:54:33 +0000587 ++InitializableMembers;
Stephen Hines651f13c2014-04-23 16:59:28 -0700588
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000589 if (structDecl->isUnion())
Eli Friedmanf84eda32008-05-25 14:03:31 +0000590 return std::min(InitializableMembers, 1);
591 return InitializableMembers - structDecl->hasFlexibleArrayMember();
Steve Naroff0cca7492008-05-01 22:18:59 +0000592}
593
Richard Smithb9bf3122013-09-20 20:10:22 +0000594/// Check whether the range of the initializer \p ParentIList from element
595/// \p Index onwards can be used to initialize an object of type \p T. Update
596/// \p Index to indicate how many elements of the list were consumed.
597///
598/// This also fills in \p StructuredList, from element \p StructuredIndex
599/// onwards, with the fully-braced, desugared form of the initialization.
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000600void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000601 InitListExpr *ParentIList,
Douglas Gregor4c678342009-01-28 21:54:33 +0000602 QualType T, unsigned &Index,
603 InitListExpr *StructuredList,
Eli Friedman629f1182011-08-23 20:17:13 +0000604 unsigned &StructuredIndex) {
Steve Naroff0cca7492008-05-01 22:18:59 +0000605 int maxElements = 0;
Mike Stump1eb44332009-09-09 15:08:12 +0000606
Steve Naroff0cca7492008-05-01 22:18:59 +0000607 if (T->isArrayType())
608 maxElements = numArrayElements(T);
Douglas Gregorfb87b892010-04-26 21:31:17 +0000609 else if (T->isRecordType())
Steve Naroff0cca7492008-05-01 22:18:59 +0000610 maxElements = numStructUnionElements(T);
Eli Friedmanb85f7072008-05-19 19:16:24 +0000611 else if (T->isVectorType())
John McCall183700f2009-09-21 23:43:11 +0000612 maxElements = T->getAs<VectorType>()->getNumElements();
Steve Naroff0cca7492008-05-01 22:18:59 +0000613 else
David Blaikieb219cfc2011-09-23 05:06:16 +0000614 llvm_unreachable("CheckImplicitInitList(): Illegal type");
Eli Friedmanb85f7072008-05-19 19:16:24 +0000615
Eli Friedman402256f2008-05-25 13:49:22 +0000616 if (maxElements == 0) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000617 if (!VerifyOnly)
618 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
619 diag::err_implicit_empty_initializer);
Douglas Gregor4c678342009-01-28 21:54:33 +0000620 ++Index;
Eli Friedman402256f2008-05-25 13:49:22 +0000621 hadError = true;
622 return;
623 }
624
Douglas Gregor4c678342009-01-28 21:54:33 +0000625 // Build a structured initializer list corresponding to this subobject.
626 InitListExpr *StructuredSubobjectInitList
Mike Stump1eb44332009-09-09 15:08:12 +0000627 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
628 StructuredIndex,
Daniel Dunbar96a00142012-03-09 18:35:03 +0000629 SourceRange(ParentIList->getInit(Index)->getLocStart(),
Douglas Gregored8a93d2009-03-01 17:12:46 +0000630 ParentIList->getSourceRange().getEnd()));
Douglas Gregor4c678342009-01-28 21:54:33 +0000631 unsigned StructuredSubobjectInitIndex = 0;
Eli Friedmanb85f7072008-05-19 19:16:24 +0000632
Douglas Gregor4c678342009-01-28 21:54:33 +0000633 // Check the element types and build the structural subobject.
Douglas Gregor87fd7032009-02-02 17:43:21 +0000634 unsigned StartIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000635 CheckListElementTypes(Entity, ParentIList, T,
Anders Carlsson987dc6a2010-01-23 20:47:59 +0000636 /*SubobjectIsDesignatorContext=*/false, Index,
Mike Stump1eb44332009-09-09 15:08:12 +0000637 StructuredSubobjectInitList,
Eli Friedman629f1182011-08-23 20:17:13 +0000638 StructuredSubobjectInitIndex);
Sebastian Redlc2235182011-10-16 18:19:28 +0000639
Richard Smith40cba902013-06-06 11:41:05 +0000640 if (!VerifyOnly) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000641 StructuredSubobjectInitList->setType(T);
Douglas Gregora6457962009-03-20 00:32:56 +0000642
Sebastian Redlc2235182011-10-16 18:19:28 +0000643 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000644 // Update the structured sub-object initializer so that it's ending
645 // range corresponds with the end of the last initializer it used.
646 if (EndIndex < ParentIList->getNumInits()) {
647 SourceLocation EndLoc
648 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
649 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
650 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000651
Sebastian Redlc2235182011-10-16 18:19:28 +0000652 // Complain about missing braces.
Sebastian Redl14b0c192011-09-24 17:48:00 +0000653 if (T->isArrayType() || T->isRecordType()) {
654 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
Richard Smith40cba902013-06-06 11:41:05 +0000655 diag::warn_missing_braces)
Stephen Hines6bcf27b2014-05-29 04:14:42 -0700656 << StructuredSubobjectInitList->getSourceRange()
657 << FixItHint::CreateInsertion(
658 StructuredSubobjectInitList->getLocStart(), "{")
659 << FixItHint::CreateInsertion(
660 SemaRef.getLocForEndOfToken(
661 StructuredSubobjectInitList->getLocEnd()),
662 "}");
Sebastian Redl14b0c192011-09-24 17:48:00 +0000663 }
Tanya Lattner1e1d3962010-03-07 04:17:15 +0000664 }
Steve Naroff0cca7492008-05-01 22:18:59 +0000665}
666
Richard Smithb9bf3122013-09-20 20:10:22 +0000667/// Check whether the initializer \p IList (that was written with explicit
668/// braces) can be used to initialize an object of type \p T.
669///
670/// This also fills in \p StructuredList with the fully-braced, desugared
671/// form of the initialization.
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000672void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000673 InitListExpr *IList, QualType &T,
Douglas Gregor4c678342009-01-28 21:54:33 +0000674 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000675 bool TopLevelObject) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000676 assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
Sebastian Redl14b0c192011-09-24 17:48:00 +0000677 if (!VerifyOnly) {
678 SyntacticToSemantic[IList] = StructuredList;
679 StructuredList->setSyntacticForm(IList);
680 }
Richard Smithb9bf3122013-09-20 20:10:22 +0000681
682 unsigned Index = 0, StructuredIndex = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000683 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
Anders Carlsson46f46592010-01-23 19:55:29 +0000684 Index, StructuredList, StructuredIndex, TopLevelObject);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000685 if (!VerifyOnly) {
Eli Friedman5c89c392012-02-23 02:25:10 +0000686 QualType ExprTy = T;
687 if (!ExprTy->isArrayType())
688 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
Sebastian Redl14b0c192011-09-24 17:48:00 +0000689 IList->setType(ExprTy);
690 StructuredList->setType(ExprTy);
691 }
Eli Friedman638e1442008-05-25 13:22:35 +0000692 if (hadError)
693 return;
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000694
Eli Friedman638e1442008-05-25 13:22:35 +0000695 if (Index < IList->getNumInits()) {
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000696 // We have leftover initializers
Sebastian Redl14b0c192011-09-24 17:48:00 +0000697 if (VerifyOnly) {
David Blaikie4e4d0842012-03-11 07:00:24 +0000698 if (SemaRef.getLangOpts().CPlusPlus ||
699 (SemaRef.getLangOpts().OpenCL &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000700 IList->getType()->isVectorType())) {
701 hadError = true;
702 }
703 return;
704 }
705
Eli Friedmane5408582009-05-29 20:20:05 +0000706 if (StructuredIndex == 1 &&
Hans Wennborgc1fb1e02013-05-16 09:22:40 +0000707 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
708 SIF_None) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000709 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
David Blaikie4e4d0842012-03-11 07:00:24 +0000710 if (SemaRef.getLangOpts().CPlusPlus) {
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000711 DK = diag::err_excess_initializers_in_char_array_initializer;
Eli Friedmane5408582009-05-29 20:20:05 +0000712 hadError = true;
713 }
Eli Friedmanbb504d32008-05-19 20:12:18 +0000714 // Special-case
Chris Lattner08202542009-02-24 22:50:46 +0000715 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000716 << IList->getInit(Index)->getSourceRange();
Eli Friedmand8dc2102008-05-20 05:25:56 +0000717 } else if (!T->isIncompleteType()) {
Douglas Gregorb574e562009-01-30 22:26:29 +0000718 // Don't complain for incomplete types, since we'll get an error
719 // elsewhere
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000720 QualType CurrentObjectType = StructuredList->getType();
Mike Stump1eb44332009-09-09 15:08:12 +0000721 int initKind =
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000722 CurrentObjectType->isArrayType()? 0 :
723 CurrentObjectType->isVectorType()? 1 :
724 CurrentObjectType->isScalarType()? 2 :
725 CurrentObjectType->isUnionType()? 3 :
726 4;
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000727
728 unsigned DK = diag::warn_excess_initializers;
David Blaikie4e4d0842012-03-11 07:00:24 +0000729 if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmane5408582009-05-29 20:20:05 +0000730 DK = diag::err_excess_initializers;
731 hadError = true;
732 }
David Blaikie4e4d0842012-03-11 07:00:24 +0000733 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
Nate Begeman08634522009-07-07 21:53:06 +0000734 DK = diag::err_excess_initializers;
735 hadError = true;
736 }
Douglas Gregor7c53ca62009-02-18 22:23:55 +0000737
Chris Lattner08202542009-02-24 22:50:46 +0000738 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000739 << initKind << IList->getInit(Index)->getSourceRange();
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000740 }
741 }
Eli Friedmancda25a92008-05-19 20:20:43 +0000742
Sebastian Redl14b0c192011-09-24 17:48:00 +0000743 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
744 !TopLevelObject)
Chris Lattner08202542009-02-24 22:50:46 +0000745 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
Douglas Gregora3a83512009-04-01 23:51:29 +0000746 << IList->getSourceRange()
Douglas Gregor849b2432010-03-31 17:46:05 +0000747 << FixItHint::CreateRemoval(IList->getLocStart())
748 << FixItHint::CreateRemoval(IList->getLocEnd());
Steve Naroff0cca7492008-05-01 22:18:59 +0000749}
750
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000751void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000752 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000753 QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +0000754 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +0000755 unsigned &Index,
756 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +0000757 unsigned &StructuredIndex,
758 bool TopLevelObject) {
Eli Friedman0c706c22011-09-19 23:17:44 +0000759 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
760 // Explicitly braced initializer for complex type can be real+imaginary
761 // parts.
762 CheckComplexType(Entity, IList, DeclType, Index,
763 StructuredList, StructuredIndex);
764 } else if (DeclType->isScalarType()) {
Anders Carlsson46f46592010-01-23 19:55:29 +0000765 CheckScalarType(Entity, IList, DeclType, Index,
766 StructuredList, StructuredIndex);
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000767 } else if (DeclType->isVectorType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000768 CheckVectorType(Entity, IList, DeclType, Index,
Anders Carlsson46f46592010-01-23 19:55:29 +0000769 StructuredList, StructuredIndex);
Richard Smith20599392012-07-07 08:35:56 +0000770 } else if (DeclType->isRecordType()) {
771 assert(DeclType->isAggregateType() &&
772 "non-aggregate records should be handed in CheckSubElementType");
773 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
774 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
775 SubobjectIsDesignatorContext, Index,
776 StructuredList, StructuredIndex,
777 TopLevelObject);
778 } else if (DeclType->isArrayType()) {
779 llvm::APSInt Zero(
780 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
781 false);
782 CheckArrayType(Entity, IList, DeclType, Zero,
783 SubobjectIsDesignatorContext, Index,
784 StructuredList, StructuredIndex);
Steve Naroff61353522008-08-10 16:05:48 +0000785 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
786 // This type is invalid, issue a diagnostic.
Douglas Gregor4c678342009-01-28 21:54:33 +0000787 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +0000788 if (!VerifyOnly)
789 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
790 << DeclType;
Eli Friedmand8dc2102008-05-20 05:25:56 +0000791 hadError = true;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000792 } else if (DeclType->isReferenceType()) {
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000793 CheckReferenceType(Entity, IList, DeclType, Index,
794 StructuredList, StructuredIndex);
John McCallc12c5bb2010-05-15 11:32:37 +0000795 } else if (DeclType->isObjCObjectType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000796 if (!VerifyOnly)
797 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
798 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000799 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000800 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000801 if (!VerifyOnly)
802 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
803 << DeclType;
Douglas Gregor4d9e7382010-05-03 18:24:37 +0000804 hadError = true;
Steve Naroff0cca7492008-05-01 22:18:59 +0000805 }
806}
807
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000808void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000809 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +0000810 QualType ElemType,
Douglas Gregor4c678342009-01-28 21:54:33 +0000811 unsigned &Index,
812 InitListExpr *StructuredList,
813 unsigned &StructuredIndex) {
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000814 Expr *expr = IList->getInit(Index);
Richard Smith6242a452013-05-31 02:56:17 +0000815
816 if (ElemType->isReferenceType())
817 return CheckReferenceType(Entity, IList, ElemType, Index,
818 StructuredList, StructuredIndex);
819
Eli Friedmanc9c0ea62008-05-19 20:00:43 +0000820 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
Richard Smith20599392012-07-07 08:35:56 +0000821 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
Richard Smithb9bf3122013-09-20 20:10:22 +0000822 InitListExpr *InnerStructuredList
Richard Smith20599392012-07-07 08:35:56 +0000823 = getStructuredSubobjectInit(IList, Index, ElemType,
824 StructuredList, StructuredIndex,
825 SubInitList->getSourceRange());
Richard Smithb9bf3122013-09-20 20:10:22 +0000826 CheckExplicitInitList(Entity, SubInitList, ElemType,
827 InnerStructuredList);
Richard Smith20599392012-07-07 08:35:56 +0000828 ++StructuredIndex;
829 ++Index;
830 return;
831 }
832 assert(SemaRef.getLangOpts().CPlusPlus &&
833 "non-aggregate records are only possible in C++");
834 // C++ initialization is handled later.
835 }
836
Eli Friedman48a2a3a2013-08-19 22:12:56 +0000837 // FIXME: Need to handle atomic aggregate types with implicit init lists.
838 if (ElemType->isScalarType() || ElemType->isAtomicType())
John McCallfef8b342011-02-21 07:57:55 +0000839 return CheckScalarType(Entity, IList, ElemType, Index,
840 StructuredList, StructuredIndex);
Anders Carlssond28b4282009-08-27 17:18:13 +0000841
Eli Friedman48a2a3a2013-08-19 22:12:56 +0000842 assert((ElemType->isRecordType() || ElemType->isVectorType() ||
843 ElemType->isArrayType()) && "Unexpected type");
844
John McCallfef8b342011-02-21 07:57:55 +0000845 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
846 // arrayType can be incomplete if we're initializing a flexible
847 // array member. There's nothing we can do with the completed
848 // type here, though.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000849
Hans Wennborg0ff50742013-05-15 11:03:04 +0000850 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
Eli Friedman8a5d9292011-09-26 19:09:09 +0000851 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +0000852 CheckStringInit(expr, ElemType, arrayType, SemaRef);
853 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
Eli Friedman8a5d9292011-09-26 19:09:09 +0000854 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000855 ++Index;
John McCallfef8b342011-02-21 07:57:55 +0000856 return;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000857 }
John McCallfef8b342011-02-21 07:57:55 +0000858
859 // Fall through for subaggregate initialization.
860
David Blaikie4e4d0842012-03-11 07:00:24 +0000861 } else if (SemaRef.getLangOpts().CPlusPlus) {
John McCallfef8b342011-02-21 07:57:55 +0000862 // C++ [dcl.init.aggr]p12:
863 // All implicit type conversions (clause 4) are considered when
Sebastian Redl5d3d41d2011-09-24 17:47:39 +0000864 // initializing the aggregate member with an initializer from
John McCallfef8b342011-02-21 07:57:55 +0000865 // an initializer-list. If the initializer can initialize a
866 // member, the member is initialized. [...]
867
868 // FIXME: Better EqualLoc?
869 InitializationKind Kind =
870 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000871 InitializationSequence Seq(SemaRef, Entity, Kind, expr);
John McCallfef8b342011-02-21 07:57:55 +0000872
873 if (Seq) {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000874 if (!VerifyOnly) {
Richard Smithb6f8d282011-12-20 04:00:21 +0000875 ExprResult Result =
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000876 Seq.Perform(SemaRef, Entity, Kind, expr);
Richard Smithb6f8d282011-12-20 04:00:21 +0000877 if (Result.isInvalid())
878 hadError = true;
John McCallfef8b342011-02-21 07:57:55 +0000879
Sebastian Redl14b0c192011-09-24 17:48:00 +0000880 UpdateStructuredListElement(StructuredList, StructuredIndex,
Richard Smithb6f8d282011-12-20 04:00:21 +0000881 Result.takeAs<Expr>());
Sebastian Redl14b0c192011-09-24 17:48:00 +0000882 }
John McCallfef8b342011-02-21 07:57:55 +0000883 ++Index;
884 return;
885 }
886
887 // Fall through for subaggregate initialization
888 } else {
889 // C99 6.7.8p13:
890 //
891 // The initializer for a structure or union object that has
892 // automatic storage duration shall be either an initializer
893 // list as described below, or a single expression that has
894 // compatible structure or union type. In the latter case, the
895 // initial value of the object, including unnamed members, is
896 // that of the expression.
John Wiegley429bb272011-04-08 18:41:53 +0000897 ExprResult ExprRes = SemaRef.Owned(expr);
John McCallfef8b342011-02-21 07:57:55 +0000898 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
Sebastian Redl14b0c192011-09-24 17:48:00 +0000899 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
900 !VerifyOnly)
Eli Friedman08f0bbc2013-09-17 04:07:04 +0000901 != Sema::Incompatible) {
John Wiegley429bb272011-04-08 18:41:53 +0000902 if (ExprRes.isInvalid())
903 hadError = true;
904 else {
905 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +0000906 if (ExprRes.isInvalid())
907 hadError = true;
John Wiegley429bb272011-04-08 18:41:53 +0000908 }
909 UpdateStructuredListElement(StructuredList, StructuredIndex,
910 ExprRes.takeAs<Expr>());
John McCallfef8b342011-02-21 07:57:55 +0000911 ++Index;
912 return;
913 }
John Wiegley429bb272011-04-08 18:41:53 +0000914 ExprRes.release();
John McCallfef8b342011-02-21 07:57:55 +0000915 // Fall through for subaggregate initialization
916 }
917
918 // C++ [dcl.init.aggr]p12:
919 //
920 // [...] Otherwise, if the member is itself a non-empty
921 // subaggregate, brace elision is assumed and the initializer is
922 // considered for the initialization of the first member of
923 // the subaggregate.
David Blaikie4e4d0842012-03-11 07:00:24 +0000924 if (!SemaRef.getLangOpts().OpenCL &&
Tanya Lattner61b4bc82011-07-15 23:07:01 +0000925 (ElemType->isAggregateType() || ElemType->isVectorType())) {
John McCallfef8b342011-02-21 07:57:55 +0000926 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
927 StructuredIndex);
928 ++StructuredIndex;
929 } else {
Sebastian Redl14b0c192011-09-24 17:48:00 +0000930 if (!VerifyOnly) {
931 // We cannot initialize this element, so let
932 // PerformCopyInitialization produce the appropriate diagnostic.
933 SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
934 SemaRef.Owned(expr),
935 /*TopLevelOfInitList=*/true);
936 }
John McCallfef8b342011-02-21 07:57:55 +0000937 hadError = true;
938 ++Index;
939 ++StructuredIndex;
Douglas Gregor930d8b52009-01-30 22:09:00 +0000940 }
Eli Friedmanb85f7072008-05-19 19:16:24 +0000941}
942
Eli Friedman0c706c22011-09-19 23:17:44 +0000943void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
944 InitListExpr *IList, QualType DeclType,
945 unsigned &Index,
946 InitListExpr *StructuredList,
947 unsigned &StructuredIndex) {
948 assert(Index == 0 && "Index in explicit init list must be zero");
949
950 // As an extension, clang supports complex initializers, which initialize
951 // a complex number component-wise. When an explicit initializer list for
952 // a complex number contains two two initializers, this extension kicks in:
953 // it exepcts the initializer list to contain two elements convertible to
954 // the element type of the complex type. The first element initializes
955 // the real part, and the second element intitializes the imaginary part.
956
957 if (IList->getNumInits() != 2)
958 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
959 StructuredIndex);
960
961 // This is an extension in C. (The builtin _Complex type does not exist
962 // in the C++ standard.)
David Blaikie4e4d0842012-03-11 07:00:24 +0000963 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
Eli Friedman0c706c22011-09-19 23:17:44 +0000964 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
965 << IList->getSourceRange();
966
967 // Initialize the complex number.
968 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
969 InitializedEntity ElementEntity =
970 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
971
972 for (unsigned i = 0; i < 2; ++i) {
973 ElementEntity.setElementIndex(Index);
974 CheckSubElementType(ElementEntity, IList, elementType, Index,
975 StructuredList, StructuredIndex);
976 }
977}
978
979
Anders Carlsson8ff9e862010-01-23 23:23:01 +0000980void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +0000981 InitListExpr *IList, QualType DeclType,
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +0000982 unsigned &Index,
Douglas Gregor4c678342009-01-28 21:54:33 +0000983 InitListExpr *StructuredList,
984 unsigned &StructuredIndex) {
John McCallb934c2d2010-11-11 00:46:36 +0000985 if (Index >= IList->getNumInits()) {
Richard Smith6b130222011-10-18 21:39:00 +0000986 if (!VerifyOnly)
987 SemaRef.Diag(IList->getLocStart(),
Richard Smith80ad52f2013-01-02 11:42:31 +0000988 SemaRef.getLangOpts().CPlusPlus11 ?
Richard Smith6b130222011-10-18 21:39:00 +0000989 diag::warn_cxx98_compat_empty_scalar_initializer :
990 diag::err_empty_scalar_initializer)
991 << IList->getSourceRange();
Richard Smith80ad52f2013-01-02 11:42:31 +0000992 hadError = !SemaRef.getLangOpts().CPlusPlus11;
Douglas Gregor4c678342009-01-28 21:54:33 +0000993 ++Index;
994 ++StructuredIndex;
Eli Friedmanbb504d32008-05-19 20:12:18 +0000995 return;
Steve Naroff0cca7492008-05-01 22:18:59 +0000996 }
John McCallb934c2d2010-11-11 00:46:36 +0000997
998 Expr *expr = IList->getInit(Index);
999 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
Stephen Hines651f13c2014-04-23 16:59:28 -07001000 // FIXME: This is invalid, and accepting it causes overload resolution
1001 // to pick the wrong overload in some corner cases.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001002 if (!VerifyOnly)
1003 SemaRef.Diag(SubIList->getLocStart(),
Stephen Hines651f13c2014-04-23 16:59:28 -07001004 diag::ext_many_braces_around_scalar_init)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001005 << SubIList->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001006
1007 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1008 StructuredIndex);
1009 return;
1010 } else if (isa<DesignatedInitExpr>(expr)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001011 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001012 SemaRef.Diag(expr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001013 diag::err_designator_for_scalar_init)
1014 << DeclType << expr->getSourceRange();
John McCallb934c2d2010-11-11 00:46:36 +00001015 hadError = true;
1016 ++Index;
1017 ++StructuredIndex;
1018 return;
1019 }
1020
Sebastian Redl14b0c192011-09-24 17:48:00 +00001021 if (VerifyOnly) {
1022 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1023 hadError = true;
1024 ++Index;
1025 return;
1026 }
1027
John McCallb934c2d2010-11-11 00:46:36 +00001028 ExprResult Result =
1029 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001030 SemaRef.Owned(expr),
1031 /*TopLevelOfInitList=*/true);
John McCallb934c2d2010-11-11 00:46:36 +00001032
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001033 Expr *ResultExpr = nullptr;
John McCallb934c2d2010-11-11 00:46:36 +00001034
1035 if (Result.isInvalid())
1036 hadError = true; // types weren't compatible.
1037 else {
1038 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001039
John McCallb934c2d2010-11-11 00:46:36 +00001040 if (ResultExpr != expr) {
1041 // The type was promoted, update initializer list.
1042 IList->setInit(Index, ResultExpr);
1043 }
1044 }
1045 if (hadError)
1046 ++StructuredIndex;
1047 else
1048 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1049 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001050}
1051
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001052void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1053 InitListExpr *IList, QualType DeclType,
Douglas Gregor930d8b52009-01-30 22:09:00 +00001054 unsigned &Index,
1055 InitListExpr *StructuredList,
1056 unsigned &StructuredIndex) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001057 if (Index >= IList->getNumInits()) {
Mike Stump390b4cc2009-05-16 07:39:55 +00001058 // FIXME: It would be wonderful if we could point at the actual member. In
1059 // general, it would be useful to pass location information down the stack,
1060 // so that we know the location (or decl) of the "current object" being
1061 // initialized.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001062 if (!VerifyOnly)
1063 SemaRef.Diag(IList->getLocStart(),
1064 diag::err_init_reference_member_uninitialized)
1065 << DeclType
1066 << IList->getSourceRange();
Douglas Gregor930d8b52009-01-30 22:09:00 +00001067 hadError = true;
1068 ++Index;
1069 ++StructuredIndex;
1070 return;
1071 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001072
1073 Expr *expr = IList->getInit(Index);
Richard Smith80ad52f2013-01-02 11:42:31 +00001074 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001075 if (!VerifyOnly)
1076 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1077 << DeclType << IList->getSourceRange();
1078 hadError = true;
1079 ++Index;
1080 ++StructuredIndex;
1081 return;
1082 }
1083
1084 if (VerifyOnly) {
1085 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1086 hadError = true;
1087 ++Index;
1088 return;
1089 }
1090
1091 ExprResult Result =
1092 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1093 SemaRef.Owned(expr),
1094 /*TopLevelOfInitList=*/true);
1095
1096 if (Result.isInvalid())
1097 hadError = true;
1098
1099 expr = Result.takeAs<Expr>();
1100 IList->setInit(Index, expr);
1101
1102 if (hadError)
1103 ++StructuredIndex;
1104 else
1105 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1106 ++Index;
Douglas Gregor930d8b52009-01-30 22:09:00 +00001107}
1108
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001109void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
Anders Carlsson46f46592010-01-23 19:55:29 +00001110 InitListExpr *IList, QualType DeclType,
Douglas Gregor4c678342009-01-28 21:54:33 +00001111 unsigned &Index,
1112 InitListExpr *StructuredList,
1113 unsigned &StructuredIndex) {
John McCall20e047a2010-10-30 00:11:39 +00001114 const VectorType *VT = DeclType->getAs<VectorType>();
1115 unsigned maxElements = VT->getNumElements();
1116 unsigned numEltsInit = 0;
1117 QualType elementType = VT->getElementType();
Anders Carlsson46f46592010-01-23 19:55:29 +00001118
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001119 if (Index >= IList->getNumInits()) {
1120 // Make sure the element type can be value-initialized.
1121 if (VerifyOnly)
1122 CheckValueInitializable(
1123 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity));
1124 return;
1125 }
1126
David Blaikie4e4d0842012-03-11 07:00:24 +00001127 if (!SemaRef.getLangOpts().OpenCL) {
John McCall20e047a2010-10-30 00:11:39 +00001128 // If the initializing element is a vector, try to copy-initialize
1129 // instead of breaking it apart (which is doomed to failure anyway).
1130 Expr *Init = IList->getInit(Index);
1131 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001132 if (VerifyOnly) {
1133 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(Init)))
1134 hadError = true;
1135 ++Index;
1136 return;
1137 }
1138
John McCall20e047a2010-10-30 00:11:39 +00001139 ExprResult Result =
1140 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(),
Jeffrey Yasskin19159132011-07-26 23:20:30 +00001141 SemaRef.Owned(Init),
1142 /*TopLevelOfInitList=*/true);
John McCall20e047a2010-10-30 00:11:39 +00001143
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001144 Expr *ResultExpr = nullptr;
John McCall20e047a2010-10-30 00:11:39 +00001145 if (Result.isInvalid())
1146 hadError = true; // types weren't compatible.
1147 else {
1148 ResultExpr = Result.takeAs<Expr>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001149
John McCall20e047a2010-10-30 00:11:39 +00001150 if (ResultExpr != Init) {
1151 // The type was promoted, update initializer list.
1152 IList->setInit(Index, ResultExpr);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001153 }
1154 }
John McCall20e047a2010-10-30 00:11:39 +00001155 if (hadError)
1156 ++StructuredIndex;
1157 else
Sebastian Redl14b0c192011-09-24 17:48:00 +00001158 UpdateStructuredListElement(StructuredList, StructuredIndex,
1159 ResultExpr);
John McCall20e047a2010-10-30 00:11:39 +00001160 ++Index;
1161 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001162 }
Mike Stump1eb44332009-09-09 15:08:12 +00001163
John McCall20e047a2010-10-30 00:11:39 +00001164 InitializedEntity ElementEntity =
1165 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001166
John McCall20e047a2010-10-30 00:11:39 +00001167 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1168 // Don't attempt to go past the end of the init list
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001169 if (Index >= IList->getNumInits()) {
1170 if (VerifyOnly)
1171 CheckValueInitializable(ElementEntity);
John McCall20e047a2010-10-30 00:11:39 +00001172 break;
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001173 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001174
John McCall20e047a2010-10-30 00:11:39 +00001175 ElementEntity.setElementIndex(Index);
1176 CheckSubElementType(ElementEntity, IList, elementType, Index,
1177 StructuredList, StructuredIndex);
1178 }
1179 return;
Steve Naroff0cca7492008-05-01 22:18:59 +00001180 }
John McCall20e047a2010-10-30 00:11:39 +00001181
1182 InitializedEntity ElementEntity =
1183 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001184
John McCall20e047a2010-10-30 00:11:39 +00001185 // OpenCL initializers allows vectors to be constructed from vectors.
1186 for (unsigned i = 0; i < maxElements; ++i) {
1187 // Don't attempt to go past the end of the init list
1188 if (Index >= IList->getNumInits())
1189 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001190
John McCall20e047a2010-10-30 00:11:39 +00001191 ElementEntity.setElementIndex(Index);
1192
1193 QualType IType = IList->getInit(Index)->getType();
1194 if (!IType->isVectorType()) {
1195 CheckSubElementType(ElementEntity, IList, elementType, Index,
1196 StructuredList, StructuredIndex);
1197 ++numEltsInit;
1198 } else {
1199 QualType VecType;
1200 const VectorType *IVT = IType->getAs<VectorType>();
1201 unsigned numIElts = IVT->getNumElements();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001202
John McCall20e047a2010-10-30 00:11:39 +00001203 if (IType->isExtVectorType())
1204 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1205 else
1206 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
Bob Wilsone86d78c2010-11-10 21:56:12 +00001207 IVT->getVectorKind());
John McCall20e047a2010-10-30 00:11:39 +00001208 CheckSubElementType(ElementEntity, IList, VecType, Index,
1209 StructuredList, StructuredIndex);
1210 numEltsInit += numIElts;
1211 }
1212 }
1213
1214 // OpenCL requires all elements to be initialized.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001215 if (numEltsInit != maxElements) {
1216 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001217 SemaRef.Diag(IList->getLocStart(),
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001218 diag::err_vector_incorrect_num_initializers)
1219 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1220 hadError = true;
1221 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001222}
1223
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001224void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
Anders Carlsson784f6992010-01-23 20:13:41 +00001225 InitListExpr *IList, QualType &DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001226 llvm::APSInt elementIndex,
Mike Stump1eb44332009-09-09 15:08:12 +00001227 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001228 unsigned &Index,
1229 InitListExpr *StructuredList,
1230 unsigned &StructuredIndex) {
John McCallce6c9b72011-02-21 07:22:22 +00001231 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1232
Steve Naroff0cca7492008-05-01 22:18:59 +00001233 // Check for the special-case of initializing an array with a string.
1234 if (Index < IList->getNumInits()) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001235 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1236 SIF_None) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001237 // We place the string literal directly into the resulting
1238 // initializer list. This is the only place where the structure
1239 // of the structured initializer list doesn't match exactly,
1240 // because doing so would involve allocating one character
1241 // constant for each string.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001242 if (!VerifyOnly) {
Hans Wennborg0ff50742013-05-15 11:03:04 +00001243 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1244 UpdateStructuredListElement(StructuredList, StructuredIndex,
1245 IList->getInit(Index));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001246 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1247 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001248 ++Index;
Steve Naroff0cca7492008-05-01 22:18:59 +00001249 return;
1250 }
1251 }
John McCallce6c9b72011-02-21 07:22:22 +00001252 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
Eli Friedman638e1442008-05-25 13:22:35 +00001253 // Check for VLAs; in standard C it would be possible to check this
1254 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1255 // them in all sorts of strange places).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001256 if (!VerifyOnly)
1257 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1258 diag::err_variable_object_no_init)
1259 << VAT->getSizeExpr()->getSourceRange();
Eli Friedman638e1442008-05-25 13:22:35 +00001260 hadError = true;
Douglas Gregor4c678342009-01-28 21:54:33 +00001261 ++Index;
1262 ++StructuredIndex;
Eli Friedman638e1442008-05-25 13:22:35 +00001263 return;
1264 }
1265
Douglas Gregor05c13a32009-01-22 00:58:24 +00001266 // We might know the maximum number of elements in advance.
Douglas Gregor4c678342009-01-28 21:54:33 +00001267 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1268 elementIndex.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001269 bool maxElementsKnown = false;
John McCallce6c9b72011-02-21 07:22:22 +00001270 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00001271 maxElements = CAT->getSize();
Jay Foad9f71a8f2010-12-07 08:25:34 +00001272 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001273 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001274 maxElementsKnown = true;
1275 }
1276
John McCallce6c9b72011-02-21 07:22:22 +00001277 QualType elementType = arrayType->getElementType();
Douglas Gregor05c13a32009-01-22 00:58:24 +00001278 while (Index < IList->getNumInits()) {
1279 Expr *Init = IList->getInit(Index);
1280 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001281 // If we're not the subobject that matches up with the '{' for
1282 // the designator, we shouldn't be handling the
1283 // designator. Return immediately.
1284 if (!SubobjectIsDesignatorContext)
1285 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001286
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001287 // Handle this designated initializer. elementIndex will be
1288 // updated to be the next array element we'll initialize.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001289 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001290 DeclType, nullptr, &elementIndex, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001291 StructuredList, StructuredIndex, true,
1292 false)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001293 hadError = true;
1294 continue;
1295 }
1296
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001297 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001298 maxElements = maxElements.extend(elementIndex.getBitWidth());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001299 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00001300 elementIndex = elementIndex.extend(maxElements.getBitWidth());
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001301 elementIndex.setIsUnsigned(maxElements.isUnsigned());
Douglas Gregorf6c717c2009-01-23 16:54:12 +00001302
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001303 // If the array is of incomplete type, keep track of the number of
1304 // elements in the initializer.
1305 if (!maxElementsKnown && elementIndex > maxElements)
1306 maxElements = elementIndex;
1307
Douglas Gregor05c13a32009-01-22 00:58:24 +00001308 continue;
1309 }
1310
1311 // If we know the maximum number of elements, and we've already
1312 // hit it, stop consuming elements in the initializer list.
1313 if (maxElementsKnown && elementIndex == maxElements)
Steve Naroff0cca7492008-05-01 22:18:59 +00001314 break;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001315
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001316 InitializedEntity ElementEntity =
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001317 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001318 Entity);
1319 // Check this element.
1320 CheckSubElementType(ElementEntity, IList, elementType, Index,
1321 StructuredList, StructuredIndex);
Douglas Gregor05c13a32009-01-22 00:58:24 +00001322 ++elementIndex;
1323
1324 // If the array is of incomplete type, keep track of the number of
1325 // elements in the initializer.
1326 if (!maxElementsKnown && elementIndex > maxElements)
1327 maxElements = elementIndex;
Steve Naroff0cca7492008-05-01 22:18:59 +00001328 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001329 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
Steve Naroff0cca7492008-05-01 22:18:59 +00001330 // If this is an incomplete array type, the actual type needs to
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001331 // be calculated here.
Douglas Gregore3fa2de2009-01-23 18:58:42 +00001332 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
Douglas Gregor05c13a32009-01-22 00:58:24 +00001333 if (maxElements == Zero) {
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001334 // Sizing an array implicitly to zero is not allowed by ISO C,
1335 // but is supported by GNU.
Chris Lattner08202542009-02-24 22:50:46 +00001336 SemaRef.Diag(IList->getLocStart(),
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001337 diag::ext_typecheck_zero_array_size);
Steve Naroff0cca7492008-05-01 22:18:59 +00001338 }
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001339
Mike Stump1eb44332009-09-09 15:08:12 +00001340 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
Daniel Dunbar396f0bf2008-08-18 20:28:46 +00001341 ArrayType::Normal, 0);
Steve Naroff0cca7492008-05-01 22:18:59 +00001342 }
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001343 if (!hadError && VerifyOnly) {
1344 // Check if there are any members of the array that get value-initialized.
1345 // If so, check if doing that is possible.
1346 // FIXME: This needs to detect holes left by designated initializers too.
1347 if (maxElementsKnown && elementIndex < maxElements)
1348 CheckValueInitializable(InitializedEntity::InitializeElement(
1349 SemaRef.Context, 0, Entity));
1350 }
Steve Naroff0cca7492008-05-01 22:18:59 +00001351}
1352
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001353bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1354 Expr *InitExpr,
1355 FieldDecl *Field,
1356 bool TopLevelObject) {
1357 // Handle GNU flexible array initializers.
1358 unsigned FlexArrayDiag;
1359 if (isa<InitListExpr>(InitExpr) &&
1360 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1361 // Empty flexible array init always allowed as an extension
1362 FlexArrayDiag = diag::ext_flexible_array_init;
David Blaikie4e4d0842012-03-11 07:00:24 +00001363 } else if (SemaRef.getLangOpts().CPlusPlus) {
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001364 // Disallow flexible array init in C++; it is not required for gcc
1365 // compatibility, and it needs work to IRGen correctly in general.
1366 FlexArrayDiag = diag::err_flexible_array_init;
1367 } else if (!TopLevelObject) {
1368 // Disallow flexible array init on non-top-level object
1369 FlexArrayDiag = diag::err_flexible_array_init;
1370 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1371 // Disallow flexible array init on anything which is not a variable.
1372 FlexArrayDiag = diag::err_flexible_array_init;
1373 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1374 // Disallow flexible array init on local variables.
1375 FlexArrayDiag = diag::err_flexible_array_init;
1376 } else {
1377 // Allow other cases.
1378 FlexArrayDiag = diag::ext_flexible_array_init;
1379 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001380
1381 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001382 SemaRef.Diag(InitExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001383 FlexArrayDiag)
Daniel Dunbar96a00142012-03-09 18:35:03 +00001384 << InitExpr->getLocStart();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001385 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1386 << Field;
1387 }
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001388
1389 return FlexArrayDiag != diag::ext_flexible_array_init;
1390}
1391
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001392void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
Anders Carlsson2bbae5d2010-01-23 20:20:40 +00001393 InitListExpr *IList,
Mike Stump1eb44332009-09-09 15:08:12 +00001394 QualType DeclType,
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001395 RecordDecl::field_iterator Field,
Mike Stump1eb44332009-09-09 15:08:12 +00001396 bool SubobjectIsDesignatorContext,
Douglas Gregor4c678342009-01-28 21:54:33 +00001397 unsigned &Index,
1398 InitListExpr *StructuredList,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001399 unsigned &StructuredIndex,
1400 bool TopLevelObject) {
Ted Kremenek6217b802009-07-29 21:53:49 +00001401 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001402
Eli Friedmanb85f7072008-05-19 19:16:24 +00001403 // If the record is invalid, some of it's members are invalid. To avoid
1404 // confusion, we forgo checking the intializer for the entire record.
1405 if (structDecl->isInvalidDecl()) {
Richard Smith72ab2772012-09-28 21:23:50 +00001406 // Assume it was supposed to consume a single initializer.
1407 ++Index;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001408 hadError = true;
1409 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001410 }
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001411
1412 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001413 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Richard Smithc3bf52c2013-04-20 22:23:05 +00001414
1415 // If there's a default initializer, use it.
1416 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1417 if (VerifyOnly)
1418 return;
1419 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1420 Field != FieldEnd; ++Field) {
1421 if (Field->hasInClassInitializer()) {
1422 StructuredList->setInitializedFieldInUnion(*Field);
1423 // FIXME: Actually build a CXXDefaultInitExpr?
1424 return;
1425 }
1426 }
1427 }
1428
1429 // Value-initialize the first named member of the union.
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001430 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1431 Field != FieldEnd; ++Field) {
1432 if (Field->getDeclName()) {
1433 if (VerifyOnly)
1434 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001435 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001436 else
David Blaikie581deb32012-06-06 20:45:41 +00001437 StructuredList->setInitializedFieldInUnion(*Field);
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001438 break;
Douglas Gregor3498bdb2009-01-29 17:44:32 +00001439 }
1440 }
1441 return;
1442 }
1443
Douglas Gregor05c13a32009-01-22 00:58:24 +00001444 // If structDecl is a forward declaration, this loop won't do
1445 // anything except look at designated initializers; That's okay,
1446 // because an error should get printed out elsewhere. It might be
1447 // worthwhile to skip over the rest of the initializer, though.
Ted Kremenek6217b802009-07-29 21:53:49 +00001448 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001449 RecordDecl::field_iterator FieldEnd = RD->field_end();
Douglas Gregordfb5e592009-02-12 19:00:39 +00001450 bool InitializedSomething = false;
John McCall80639de2010-03-11 19:32:38 +00001451 bool CheckForMissingFields = true;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001452 while (Index < IList->getNumInits()) {
1453 Expr *Init = IList->getInit(Index);
1454
1455 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001456 // If we're not the subobject that matches up with the '{' for
1457 // the designator, we shouldn't be handling the
1458 // designator. Return immediately.
1459 if (!SubobjectIsDesignatorContext)
1460 return;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001461
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001462 // Handle this designated initializer. Field will be updated to
1463 // the next field that we'll be initializing.
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001464 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001465 DeclType, &Field, nullptr, Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001466 StructuredList, StructuredIndex,
1467 true, TopLevelObject))
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001468 hadError = true;
1469
Douglas Gregordfb5e592009-02-12 19:00:39 +00001470 InitializedSomething = true;
John McCall80639de2010-03-11 19:32:38 +00001471
1472 // Disable check for missing fields when designators are used.
1473 // This matches gcc behaviour.
1474 CheckForMissingFields = false;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001475 continue;
1476 }
1477
1478 if (Field == FieldEnd) {
1479 // We've run out of fields. We're done.
1480 break;
1481 }
1482
Douglas Gregordfb5e592009-02-12 19:00:39 +00001483 // We've already initialized a member of a union. We're done.
1484 if (InitializedSomething && DeclType->isUnionType())
1485 break;
1486
Douglas Gregor44b43212008-12-11 16:49:14 +00001487 // If we've hit the flexible array member at the end, we're done.
1488 if (Field->getType()->isIncompleteArrayType())
1489 break;
1490
Douglas Gregor0bb76892009-01-29 16:53:55 +00001491 if (Field->isUnnamedBitfield()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001492 // Don't initialize unnamed bitfields, e.g. "int : 20;"
Douglas Gregor05c13a32009-01-22 00:58:24 +00001493 ++Field;
Eli Friedmanb85f7072008-05-19 19:16:24 +00001494 continue;
Steve Naroff0cca7492008-05-01 22:18:59 +00001495 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001496
Douglas Gregor54001c12011-06-29 21:51:31 +00001497 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001498 bool InvalidUse;
1499 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001500 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001501 else
David Blaikie581deb32012-06-06 20:45:41 +00001502 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001503 IList->getInit(Index)->getLocStart());
1504 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001505 ++Index;
1506 ++Field;
1507 hadError = true;
1508 continue;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001509 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001510
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001511 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001512 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001513 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1514 StructuredList, StructuredIndex);
Douglas Gregordfb5e592009-02-12 19:00:39 +00001515 InitializedSomething = true;
Douglas Gregor0bb76892009-01-29 16:53:55 +00001516
Sebastian Redl14b0c192011-09-24 17:48:00 +00001517 if (DeclType->isUnionType() && !VerifyOnly) {
Douglas Gregor0bb76892009-01-29 16:53:55 +00001518 // Initialize the first field within the union.
David Blaikie581deb32012-06-06 20:45:41 +00001519 StructuredList->setInitializedFieldInUnion(*Field);
Douglas Gregor0bb76892009-01-29 16:53:55 +00001520 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00001521
1522 ++Field;
Steve Naroff0cca7492008-05-01 22:18:59 +00001523 }
Douglas Gregor44b43212008-12-11 16:49:14 +00001524
John McCall80639de2010-03-11 19:32:38 +00001525 // Emit warnings for missing struct field initializers.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001526 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1527 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1528 !DeclType->isUnionType()) {
John McCall80639de2010-03-11 19:32:38 +00001529 // It is possible we have one or more unnamed bitfields remaining.
1530 // Find first (if any) named field and emit warning.
1531 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1532 it != end; ++it) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001533 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
John McCall80639de2010-03-11 19:32:38 +00001534 SemaRef.Diag(IList->getSourceRange().getEnd(),
Stephen Hines651f13c2014-04-23 16:59:28 -07001535 diag::warn_missing_field_initializers) << *it;
John McCall80639de2010-03-11 19:32:38 +00001536 break;
1537 }
1538 }
1539 }
1540
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001541 // Check that any remaining fields can be value-initialized.
1542 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1543 !Field->getType()->isIncompleteArrayType()) {
1544 // FIXME: Should check for holes left by designated initializers too.
1545 for (; Field != FieldEnd && !hadError; ++Field) {
Richard Smithc3bf52c2013-04-20 22:23:05 +00001546 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001547 CheckValueInitializable(
David Blaikie581deb32012-06-06 20:45:41 +00001548 InitializedEntity::InitializeMember(*Field, &Entity));
Sebastian Redl3ff5c862011-10-16 18:19:20 +00001549 }
1550 }
1551
Mike Stump1eb44332009-09-09 15:08:12 +00001552 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
Douglas Gregora6457962009-03-20 00:32:56 +00001553 Index >= IList->getNumInits())
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001554 return;
1555
David Blaikie581deb32012-06-06 20:45:41 +00001556 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001557 TopLevelObject)) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001558 hadError = true;
Douglas Gregora6457962009-03-20 00:32:56 +00001559 ++Index;
1560 return;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001561 }
1562
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001563 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001564 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001565
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001566 if (isa<InitListExpr>(IList->getInit(Index)))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001567 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001568 StructuredList, StructuredIndex);
1569 else
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001570 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
Anders Carlsson987dc6a2010-01-23 20:47:59 +00001571 StructuredList, StructuredIndex);
Steve Naroff0cca7492008-05-01 22:18:59 +00001572}
Steve Naroff0cca7492008-05-01 22:18:59 +00001573
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001574/// \brief Expand a field designator that refers to a member of an
1575/// anonymous struct or union into a series of field designators that
1576/// refers to the field within the appropriate subobject.
1577///
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001578static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
Mike Stump1eb44332009-09-09 15:08:12 +00001579 DesignatedInitExpr *DIE,
1580 unsigned DesigIdx,
Francois Picheta0e27f02010-12-22 03:46:10 +00001581 IndirectFieldDecl *IndirectField) {
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001582 typedef DesignatedInitExpr::Designator Designator;
1583
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001584 // Build the replacement designators.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001585 SmallVector<Designator, 4> Replacements;
Francois Picheta0e27f02010-12-22 03:46:10 +00001586 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1587 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1588 if (PI + 1 == PE)
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001589 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001590 DIE->getDesignator(DesigIdx)->getDotLoc(),
1591 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1592 else
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001593 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1594 SourceLocation(), SourceLocation()));
Francois Picheta0e27f02010-12-22 03:46:10 +00001595 assert(isa<FieldDecl>(*PI));
1596 Replacements.back().setField(cast<FieldDecl>(*PI));
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001597 }
1598
1599 // Expand the current designator into the set of replacement
1600 // designators, so we have a full subobject path down to where the
1601 // member of the anonymous struct/union is actually stored.
Douglas Gregor319d57f2010-01-06 23:17:19 +00001602 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001603 &Replacements[0] + Replacements.size());
Francois Picheta0e27f02010-12-22 03:46:10 +00001604}
Mike Stump1eb44332009-09-09 15:08:12 +00001605
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001606/// \brief Given an implicit anonymous field, search the IndirectField that
Francois Picheta0e27f02010-12-22 03:46:10 +00001607/// corresponds to FieldName.
1608static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField,
1609 IdentifierInfo *FieldName) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001610 if (!FieldName)
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001611 return nullptr;
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001612
Francois Picheta0e27f02010-12-22 03:46:10 +00001613 assert(AnonField->isAnonymousStructOrUnion());
1614 Decl *NextDecl = AnonField->getNextDeclInContext();
Aaron Ballman3e78b192012-02-09 22:16:56 +00001615 while (IndirectFieldDecl *IF =
1616 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) {
Argyrios Kyrtzidisb22b0a52012-09-10 22:04:26 +00001617 if (FieldName == IF->getAnonField()->getIdentifier())
Francois Picheta0e27f02010-12-22 03:46:10 +00001618 return IF;
1619 NextDecl = NextDecl->getNextDeclInContext();
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001620 }
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001621 return nullptr;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001622}
1623
Sebastian Redl14b0c192011-09-24 17:48:00 +00001624static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1625 DesignatedInitExpr *DIE) {
1626 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1627 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1628 for (unsigned I = 0; I < NumIndexExprs; ++I)
1629 IndexExprs[I] = DIE->getSubExpr(I + 1);
1630 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001631 DIE->size(), IndexExprs,
1632 DIE->getEqualOrColonLoc(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001633 DIE->usesGNUSyntax(), DIE->getInit());
1634}
1635
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001636namespace {
1637
1638// Callback to only accept typo corrections that are for field members of
1639// the given struct or union.
1640class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1641 public:
1642 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1643 : Record(RD) {}
1644
Stephen Hines651f13c2014-04-23 16:59:28 -07001645 bool ValidateCandidate(const TypoCorrection &candidate) override {
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001646 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1647 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1648 }
1649
1650 private:
1651 RecordDecl *Record;
1652};
1653
1654}
1655
Douglas Gregor05c13a32009-01-22 00:58:24 +00001656/// @brief Check the well-formedness of a C99 designated initializer.
1657///
1658/// Determines whether the designated initializer @p DIE, which
1659/// resides at the given @p Index within the initializer list @p
1660/// IList, is well-formed for a current object of type @p DeclType
1661/// (C99 6.7.8). The actual subobject that this designator refers to
Mike Stump1eb44332009-09-09 15:08:12 +00001662/// within the current subobject is returned in either
Douglas Gregor4c678342009-01-28 21:54:33 +00001663/// @p NextField or @p NextElementIndex (whichever is appropriate).
Douglas Gregor05c13a32009-01-22 00:58:24 +00001664///
1665/// @param IList The initializer list in which this designated
1666/// initializer occurs.
1667///
Douglas Gregor71199712009-04-15 04:56:10 +00001668/// @param DIE The designated initializer expression.
1669///
1670/// @param DesigIdx The index of the current designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001671///
Dmitri Gribenko70517ca2012-08-23 17:58:28 +00001672/// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
Douglas Gregor05c13a32009-01-22 00:58:24 +00001673/// into which the designation in @p DIE should refer.
1674///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001675/// @param NextField If non-NULL and the first designator in @p DIE is
1676/// a field, this will be set to the field declaration corresponding
1677/// to the field named by the designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001678///
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001679/// @param NextElementIndex If non-NULL and the first designator in @p
1680/// DIE is an array designator or GNU array-range designator, this
1681/// will be set to the last index initialized by this designator.
Douglas Gregor05c13a32009-01-22 00:58:24 +00001682///
1683/// @param Index Index into @p IList where the designated initializer
1684/// @p DIE occurs.
1685///
Douglas Gregor4c678342009-01-28 21:54:33 +00001686/// @param StructuredList The initializer list expression that
1687/// describes all of the subobject initializers in the order they'll
1688/// actually be initialized.
1689///
Douglas Gregor05c13a32009-01-22 00:58:24 +00001690/// @returns true if there was an error, false otherwise.
Mike Stump1eb44332009-09-09 15:08:12 +00001691bool
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001692InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001693 InitListExpr *IList,
Sebastian Redl14b0c192011-09-24 17:48:00 +00001694 DesignatedInitExpr *DIE,
1695 unsigned DesigIdx,
1696 QualType &CurrentObjectType,
1697 RecordDecl::field_iterator *NextField,
1698 llvm::APSInt *NextElementIndex,
1699 unsigned &Index,
1700 InitListExpr *StructuredList,
1701 unsigned &StructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001702 bool FinishSubobjectInit,
1703 bool TopLevelObject) {
Douglas Gregor71199712009-04-15 04:56:10 +00001704 if (DesigIdx == DIE->size()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001705 // Check the actual initialization for the designated object type.
1706 bool prevHadError = hadError;
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001707
1708 // Temporarily remove the designator expression from the
1709 // initializer list that the child calls see, so that we don't try
1710 // to re-process the designator.
1711 unsigned OldIndex = Index;
1712 IList->setInit(OldIndex, DIE->getInit());
1713
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001714 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00001715 StructuredList, StructuredIndex);
Douglas Gregor6fbdc6b2009-01-29 00:39:20 +00001716
1717 // Restore the designated initializer expression in the syntactic
1718 // form of the initializer list.
1719 if (IList->getInit(OldIndex) != DIE->getInit())
1720 DIE->setInit(IList->getInit(OldIndex));
1721 IList->setInit(OldIndex, DIE);
1722
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001723 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00001724 }
1725
Douglas Gregor71199712009-04-15 04:56:10 +00001726 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001727 bool IsFirstDesignator = (DesigIdx == 0);
1728 if (!VerifyOnly) {
1729 assert((IsFirstDesignator || StructuredList) &&
1730 "Need a non-designated initializer list to start from");
1731
1732 // Determine the structural initializer list that corresponds to the
1733 // current subobject.
Benjamin Kramera7894162012-02-23 14:48:40 +00001734 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
Sebastian Redl14b0c192011-09-24 17:48:00 +00001735 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1736 StructuredList, StructuredIndex,
Erik Verbruggen65d78312012-12-25 14:51:39 +00001737 SourceRange(D->getLocStart(),
1738 DIE->getLocEnd()));
Sebastian Redl14b0c192011-09-24 17:48:00 +00001739 assert(StructuredList && "Expected a structured initializer list");
1740 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001741
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001742 if (D->isFieldDesignator()) {
1743 // C99 6.7.8p7:
1744 //
1745 // If a designator has the form
1746 //
1747 // . identifier
1748 //
1749 // then the current object (defined below) shall have
1750 // structure or union type and the identifier shall be the
Mike Stump1eb44332009-09-09 15:08:12 +00001751 // name of a member of that type.
Ted Kremenek6217b802009-07-29 21:53:49 +00001752 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001753 if (!RT) {
1754 SourceLocation Loc = D->getDotLoc();
1755 if (Loc.isInvalid())
1756 Loc = D->getFieldLoc();
Sebastian Redl14b0c192011-09-24 17:48:00 +00001757 if (!VerifyOnly)
1758 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
David Blaikie4e4d0842012-03-11 07:00:24 +00001759 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001760 ++Index;
1761 return true;
1762 }
1763
Douglas Gregor4c678342009-01-28 21:54:33 +00001764 // Note: we perform a linear search of the fields here, despite
1765 // the fact that we have a faster lookup method, because we always
1766 // need to compute the field's index.
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001767 FieldDecl *KnownField = D->getField();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001768 IdentifierInfo *FieldName = D->getFieldName();
Douglas Gregor4c678342009-01-28 21:54:33 +00001769 unsigned FieldIndex = 0;
Mike Stump1eb44332009-09-09 15:08:12 +00001770 RecordDecl::field_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001771 Field = RT->getDecl()->field_begin(),
1772 FieldEnd = RT->getDecl()->field_end();
Douglas Gregor4c678342009-01-28 21:54:33 +00001773 for (; Field != FieldEnd; ++Field) {
1774 if (Field->isUnnamedBitfield())
1775 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001776
Francois Picheta0e27f02010-12-22 03:46:10 +00001777 // If we find a field representing an anonymous field, look in the
1778 // IndirectFieldDecl that follow for the designated initializer.
1779 if (!KnownField && Field->isAnonymousStructOrUnion()) {
1780 if (IndirectFieldDecl *IF =
David Blaikie581deb32012-06-06 20:45:41 +00001781 FindIndirectFieldDesignator(*Field, FieldName)) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00001782 // In verify mode, don't modify the original.
1783 if (VerifyOnly)
1784 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
Francois Picheta0e27f02010-12-22 03:46:10 +00001785 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF);
1786 D = DIE->getDesignator(DesigIdx);
1787 break;
1788 }
1789 }
David Blaikie581deb32012-06-06 20:45:41 +00001790 if (KnownField && KnownField == *Field)
Douglas Gregor022d13d2010-10-08 20:44:28 +00001791 break;
1792 if (FieldName && FieldName == Field->getIdentifier())
Douglas Gregor4c678342009-01-28 21:54:33 +00001793 break;
1794
1795 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001796 }
1797
Douglas Gregor4c678342009-01-28 21:54:33 +00001798 if (Field == FieldEnd) {
Benjamin Kramera41ee492011-09-25 02:41:26 +00001799 if (VerifyOnly) {
1800 ++Index;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001801 return true; // No typo correction when just trying this out.
Benjamin Kramera41ee492011-09-25 02:41:26 +00001802 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00001803
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001804 // There was no normal field in the struct with the designated
1805 // name. Perform another lookup for this name, which may find
1806 // something that we can't designate (e.g., a member function),
1807 // may find nothing, or may find a member of an anonymous
Mike Stump1eb44332009-09-09 15:08:12 +00001808 // struct/union.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001809 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001810 FieldDecl *ReplacementField = nullptr;
David Blaikie3bc93e32012-12-19 00:45:41 +00001811 if (Lookup.empty()) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001812 // Name lookup didn't find anything. Determine whether this
1813 // was a typo for another field name.
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001814 FieldInitializerValidatorCCC Validator(RT->getDecl());
Richard Smith2d670972013-08-17 00:46:16 +00001815 if (TypoCorrection Corrected = SemaRef.CorrectTypo(
1816 DeclarationNameInfo(FieldName, D->getFieldLoc()),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001817 Sema::LookupMemberName, /*Scope=*/ nullptr, /*SS=*/ nullptr,
1818 Validator, Sema::CTK_ErrorRecovery, RT->getDecl())) {
Richard Smith2d670972013-08-17 00:46:16 +00001819 SemaRef.diagnoseTypo(
1820 Corrected,
1821 SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
1822 << FieldName << CurrentObjectType);
Kaelyn Uhrain425d6312012-01-12 19:27:05 +00001823 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>();
Benjamin Kramera41ee492011-09-25 02:41:26 +00001824 hadError = true;
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001825 } else {
1826 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1827 << FieldName << CurrentObjectType;
1828 ++Index;
1829 return true;
1830 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001831 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001832
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001833 if (!ReplacementField) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001834 // Name lookup found something, but it wasn't a field.
Chris Lattner08202542009-02-24 22:50:46 +00001835 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
Douglas Gregor4c678342009-01-28 21:54:33 +00001836 << FieldName;
David Blaikie3bc93e32012-12-19 00:45:41 +00001837 SemaRef.Diag(Lookup.front()->getLocation(),
Douglas Gregor4c678342009-01-28 21:54:33 +00001838 diag::note_field_designator_found);
Eli Friedmanba79fc22009-04-16 17:49:48 +00001839 ++Index;
1840 return true;
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001841 }
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001842
Francois Picheta0e27f02010-12-22 03:46:10 +00001843 if (!KnownField) {
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001844 // The replacement field comes from typo correction; find it
1845 // in the list of fields.
1846 FieldIndex = 0;
1847 Field = RT->getDecl()->field_begin();
1848 for (; Field != FieldEnd; ++Field) {
1849 if (Field->isUnnamedBitfield())
1850 continue;
1851
David Blaikie581deb32012-06-06 20:45:41 +00001852 if (ReplacementField == *Field ||
Douglas Gregorc171e3b2010-01-01 00:03:05 +00001853 Field->getIdentifier() == ReplacementField->getIdentifier())
1854 break;
1855
1856 ++FieldIndex;
1857 }
1858 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001859 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001860
1861 // All of the fields of a union are located at the same place in
1862 // the initializer list.
Douglas Gregor0bb76892009-01-29 16:53:55 +00001863 if (RT->getDecl()->isUnion()) {
Douglas Gregor4c678342009-01-28 21:54:33 +00001864 FieldIndex = 0;
Matthew Curtis4e499522013-10-03 12:14:24 +00001865 if (!VerifyOnly) {
1866 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
1867 if (CurrentField && CurrentField != *Field) {
1868 assert(StructuredList->getNumInits() == 1
1869 && "A union should never have more than one initializer!");
1870
1871 // we're about to throw away an initializer, emit warning
1872 SemaRef.Diag(D->getFieldLoc(),
1873 diag::warn_initializer_overrides)
1874 << D->getSourceRange();
1875 Expr *ExistingInit = StructuredList->getInit(0);
1876 SemaRef.Diag(ExistingInit->getLocStart(),
1877 diag::note_previous_initializer)
1878 << /*FIXME:has side effects=*/0
1879 << ExistingInit->getSourceRange();
1880
1881 // remove existing initializer
1882 StructuredList->resizeInits(SemaRef.Context, 0);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001883 StructuredList->setInitializedFieldInUnion(nullptr);
Matthew Curtis4e499522013-10-03 12:14:24 +00001884 }
1885
David Blaikie581deb32012-06-06 20:45:41 +00001886 StructuredList->setInitializedFieldInUnion(*Field);
Matthew Curtis4e499522013-10-03 12:14:24 +00001887 }
Douglas Gregor0bb76892009-01-29 16:53:55 +00001888 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001889
Douglas Gregor54001c12011-06-29 21:51:31 +00001890 // Make sure we can use this declaration.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001891 bool InvalidUse;
1892 if (VerifyOnly)
David Blaikie581deb32012-06-06 20:45:41 +00001893 InvalidUse = !SemaRef.CanUseDecl(*Field);
Sebastian Redl14b0c192011-09-24 17:48:00 +00001894 else
David Blaikie581deb32012-06-06 20:45:41 +00001895 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001896 if (InvalidUse) {
Douglas Gregor54001c12011-06-29 21:51:31 +00001897 ++Index;
1898 return true;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001899 }
Douglas Gregor54001c12011-06-29 21:51:31 +00001900
Sebastian Redl14b0c192011-09-24 17:48:00 +00001901 if (!VerifyOnly) {
1902 // Update the designator with the field declaration.
David Blaikie581deb32012-06-06 20:45:41 +00001903 D->setField(*Field);
Mike Stump1eb44332009-09-09 15:08:12 +00001904
Sebastian Redl14b0c192011-09-24 17:48:00 +00001905 // Make sure that our non-designated initializer list has space
1906 // for a subobject corresponding to this field.
1907 if (FieldIndex >= StructuredList->getNumInits())
1908 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1909 }
Douglas Gregor4c678342009-01-28 21:54:33 +00001910
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001911 // This designator names a flexible array member.
1912 if (Field->getType()->isIncompleteArrayType()) {
1913 bool Invalid = false;
Douglas Gregor71199712009-04-15 04:56:10 +00001914 if ((DesigIdx + 1) != DIE->size()) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001915 // We can't designate an object within the flexible array
1916 // member (because GCC doesn't allow it).
Sebastian Redl14b0c192011-09-24 17:48:00 +00001917 if (!VerifyOnly) {
1918 DesignatedInitExpr::Designator *NextD
1919 = DIE->getDesignator(DesigIdx + 1);
Erik Verbruggen65d78312012-12-25 14:51:39 +00001920 SemaRef.Diag(NextD->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001921 diag::err_designator_into_flexible_array_member)
Erik Verbruggen65d78312012-12-25 14:51:39 +00001922 << SourceRange(NextD->getLocStart(),
1923 DIE->getLocEnd());
Sebastian Redl14b0c192011-09-24 17:48:00 +00001924 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001925 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001926 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001927 Invalid = true;
1928 }
1929
Chris Lattner9046c222010-10-10 17:49:49 +00001930 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
1931 !isa<StringLiteral>(DIE->getInit())) {
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001932 // The initializer is not an initializer list.
Sebastian Redl14b0c192011-09-24 17:48:00 +00001933 if (!VerifyOnly) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00001934 SemaRef.Diag(DIE->getInit()->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00001935 diag::err_flexible_array_init_needs_braces)
1936 << DIE->getInit()->getSourceRange();
1937 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
David Blaikie581deb32012-06-06 20:45:41 +00001938 << *Field;
Sebastian Redl14b0c192011-09-24 17:48:00 +00001939 }
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001940 Invalid = true;
1941 }
1942
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001943 // Check GNU flexible array initializer.
David Blaikie581deb32012-06-06 20:45:41 +00001944 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
Eli Friedmanf40fd6b2011-08-23 22:24:57 +00001945 TopLevelObject))
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001946 Invalid = true;
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001947
1948 if (Invalid) {
1949 ++Index;
1950 return true;
1951 }
1952
1953 // Initialize the array.
1954 bool prevHadError = hadError;
1955 unsigned newStructuredIndex = FieldIndex;
1956 unsigned OldIndex = Index;
1957 IList->setInit(Index, DIE->getInit());
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001958
1959 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001960 InitializedEntity::InitializeMember(*Field, &Entity);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001961 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001962 StructuredList, newStructuredIndex);
Anders Carlsson8ff9e862010-01-23 23:23:01 +00001963
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001964 IList->setInit(OldIndex, DIE);
1965 if (hadError && !prevHadError) {
1966 ++Field;
1967 ++FieldIndex;
1968 if (NextField)
1969 *NextField = Field;
1970 StructuredIndex = FieldIndex;
1971 return true;
1972 }
1973 } else {
1974 // Recurse to check later designated subobjects.
David Blaikie262bc182012-04-30 02:36:29 +00001975 QualType FieldType = Field->getType();
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001976 unsigned newStructuredIndex = FieldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001977
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001978 InitializedEntity MemberEntity =
David Blaikie581deb32012-06-06 20:45:41 +00001979 InitializedEntity::InitializeMember(*Field, &Entity);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001980 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07001981 FieldType, nullptr, nullptr, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00001982 StructuredList, newStructuredIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00001983 true, false))
1984 return true;
1985 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001986
1987 // Find the position of the next field to be initialized in this
1988 // subobject.
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001989 ++Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001990 ++FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001991
1992 // If this the first designator, our caller will continue checking
1993 // the rest of this struct/class/union subobject.
1994 if (IsFirstDesignator) {
1995 if (NextField)
1996 *NextField = Field;
Douglas Gregor4c678342009-01-28 21:54:33 +00001997 StructuredIndex = FieldIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00001998 return false;
1999 }
2000
Douglas Gregor34e79462009-01-28 23:36:17 +00002001 if (!FinishSubobjectInit)
2002 return false;
2003
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00002004 // We've already initialized something in the union; we're done.
2005 if (RT->getDecl()->isUnion())
2006 return hadError;
2007
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002008 // Check the remaining fields within this class/struct/union subobject.
2009 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002010
Anders Carlsson8ff9e862010-01-23 23:23:01 +00002011 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002012 StructuredList, FieldIndex);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002013 return hadError && !prevHadError;
2014 }
2015
2016 // C99 6.7.8p6:
2017 //
2018 // If a designator has the form
2019 //
2020 // [ constant-expression ]
2021 //
2022 // then the current object (defined below) shall have array
2023 // type and the expression shall be an integer constant
2024 // expression. If the array is of unknown size, any
2025 // nonnegative value is valid.
2026 //
2027 // Additionally, cope with the GNU extension that permits
2028 // designators of the form
2029 //
2030 // [ constant-expression ... constant-expression ]
Chris Lattner08202542009-02-24 22:50:46 +00002031 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002032 if (!AT) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002033 if (!VerifyOnly)
2034 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2035 << CurrentObjectType;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002036 ++Index;
2037 return true;
2038 }
2039
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002040 Expr *IndexExpr = nullptr;
Douglas Gregor34e79462009-01-28 23:36:17 +00002041 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2042 if (D->isArrayDesignator()) {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002043 IndexExpr = DIE->getArrayIndex(*D);
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002044 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor34e79462009-01-28 23:36:17 +00002045 DesignatedEndIndex = DesignatedStartIndex;
2046 } else {
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002047 assert(D->isArrayRangeDesignator() && "Need array-range designator");
Douglas Gregor34e79462009-01-28 23:36:17 +00002048
Mike Stump1eb44332009-09-09 15:08:12 +00002049 DesignatedStartIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002050 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
Mike Stump1eb44332009-09-09 15:08:12 +00002051 DesignatedEndIndex =
Richard Smitha6b8b2c2011-10-10 18:28:20 +00002052 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002053 IndexExpr = DIE->getArrayRangeEnd(*D);
Douglas Gregor34e79462009-01-28 23:36:17 +00002054
Chris Lattnere0fd8322011-02-19 22:28:58 +00002055 // Codegen can't handle evaluating array range designators that have side
2056 // effects, because we replicate the AST value for each initialized element.
2057 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2058 // elements with something that has a side effect, so codegen can emit an
2059 // "error unsupported" error instead of miscompiling the app.
2060 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
Sebastian Redl14b0c192011-09-24 17:48:00 +00002061 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
Douglas Gregora9c87802009-01-29 19:42:23 +00002062 FullyStructuredList->sawArrayRangeDesignator();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002063 }
2064
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002065 if (isa<ConstantArrayType>(AT)) {
2066 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
Jay Foad9f71a8f2010-12-07 08:25:34 +00002067 DesignatedStartIndex
2068 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002069 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
Jay Foad9f71a8f2010-12-07 08:25:34 +00002070 DesignatedEndIndex
2071 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002072 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2073 if (DesignatedEndIndex >= MaxElements) {
Eli Friedmana4e20e12011-09-26 18:53:43 +00002074 if (!VerifyOnly)
Daniel Dunbar96a00142012-03-09 18:35:03 +00002075 SemaRef.Diag(IndexExpr->getLocStart(),
Sebastian Redl14b0c192011-09-24 17:48:00 +00002076 diag::err_array_designator_too_large)
2077 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2078 << IndexExpr->getSourceRange();
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002079 ++Index;
2080 return true;
2081 }
Douglas Gregor34e79462009-01-28 23:36:17 +00002082 } else {
2083 // Make sure the bit-widths and signedness match.
2084 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002085 DesignatedEndIndex
2086 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
Chris Lattner3bf68932009-04-25 21:59:05 +00002087 else if (DesignatedStartIndex.getBitWidth() <
2088 DesignatedEndIndex.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002089 DesignatedStartIndex
2090 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
Douglas Gregor34e79462009-01-28 23:36:17 +00002091 DesignatedStartIndex.setIsUnsigned(true);
2092 DesignatedEndIndex.setIsUnsigned(true);
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002093 }
Mike Stump1eb44332009-09-09 15:08:12 +00002094
Eli Friedman188ddb12013-06-11 21:48:11 +00002095 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2096 // We're modifying a string literal init; we have to decompose the string
2097 // so we can modify the individual characters.
2098 ASTContext &Context = SemaRef.Context;
2099 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2100
2101 // Compute the character type
2102 QualType CharTy = AT->getElementType();
2103
2104 // Compute the type of the integer literals.
2105 QualType PromotedCharTy = CharTy;
2106 if (CharTy->isPromotableIntegerType())
2107 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2108 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2109
2110 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2111 // Get the length of the string.
2112 uint64_t StrLen = SL->getLength();
2113 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2114 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2115 StructuredList->resizeInits(Context, StrLen);
2116
2117 // Build a literal for each character in the string, and put them into
2118 // the init list.
2119 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2120 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2121 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002122 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002123 if (CharTy != PromotedCharTy)
2124 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002125 Init, nullptr, VK_RValue);
Eli Friedman188ddb12013-06-11 21:48:11 +00002126 StructuredList->updateInit(Context, i, Init);
2127 }
2128 } else {
2129 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2130 std::string Str;
2131 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2132
2133 // Get the length of the string.
2134 uint64_t StrLen = Str.size();
2135 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2136 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2137 StructuredList->resizeInits(Context, StrLen);
2138
2139 // Build a literal for each character in the string, and put them into
2140 // the init list.
2141 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2142 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2143 Expr *Init = new (Context) IntegerLiteral(
Eli Friedman81359b02013-06-11 22:26:34 +00002144 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
Eli Friedman188ddb12013-06-11 21:48:11 +00002145 if (CharTy != PromotedCharTy)
2146 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002147 Init, nullptr, VK_RValue);
Eli Friedman188ddb12013-06-11 21:48:11 +00002148 StructuredList->updateInit(Context, i, Init);
2149 }
2150 }
2151 }
2152
Douglas Gregor4c678342009-01-28 21:54:33 +00002153 // Make sure that our non-designated initializer list has space
2154 // for a subobject corresponding to this array element.
Sebastian Redl14b0c192011-09-24 17:48:00 +00002155 if (!VerifyOnly &&
2156 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
Mike Stump1eb44332009-09-09 15:08:12 +00002157 StructuredList->resizeInits(SemaRef.Context,
Douglas Gregor34e79462009-01-28 23:36:17 +00002158 DesignatedEndIndex.getZExtValue() + 1);
Douglas Gregor4c678342009-01-28 21:54:33 +00002159
Douglas Gregor34e79462009-01-28 23:36:17 +00002160 // Repeatedly perform subobject initializations in the range
2161 // [DesignatedStartIndex, DesignatedEndIndex].
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002162
Douglas Gregor34e79462009-01-28 23:36:17 +00002163 // Move to the next designator
2164 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2165 unsigned OldIndex = Index;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002166
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002167 InitializedEntity ElementEntity =
Anders Carlsson8ff9e862010-01-23 23:23:01 +00002168 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002169
Douglas Gregor34e79462009-01-28 23:36:17 +00002170 while (DesignatedStartIndex <= DesignatedEndIndex) {
2171 // Recurse to check later designated subobjects.
2172 QualType ElementType = AT->getElementType();
2173 Index = OldIndex;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002174
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002175 ElementEntity.setElementIndex(ElementIndex);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002176 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002177 ElementType, nullptr, nullptr, Index,
Anders Carlsson9a8a70e2010-01-23 22:49:02 +00002178 StructuredList, ElementIndex,
Douglas Gregoreeb15d42009-02-04 22:46:25 +00002179 (DesignatedStartIndex == DesignatedEndIndex),
2180 false))
Douglas Gregor34e79462009-01-28 23:36:17 +00002181 return true;
2182
2183 // Move to the next index in the array that we'll be initializing.
2184 ++DesignatedStartIndex;
2185 ElementIndex = DesignatedStartIndex.getZExtValue();
2186 }
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002187
2188 // If this the first designator, our caller will continue checking
2189 // the rest of this array subobject.
2190 if (IsFirstDesignator) {
2191 if (NextElementIndex)
Douglas Gregor34e79462009-01-28 23:36:17 +00002192 *NextElementIndex = DesignatedStartIndex;
Douglas Gregor4c678342009-01-28 21:54:33 +00002193 StructuredIndex = ElementIndex;
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002194 return false;
2195 }
Mike Stump1eb44332009-09-09 15:08:12 +00002196
Douglas Gregor34e79462009-01-28 23:36:17 +00002197 if (!FinishSubobjectInit)
2198 return false;
2199
Douglas Gregor87f55cf2009-01-22 23:26:18 +00002200 // Check the remaining elements within this array subobject.
Douglas Gregor05c13a32009-01-22 00:58:24 +00002201 bool prevHadError = hadError;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002202 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
Anders Carlsson784f6992010-01-23 20:13:41 +00002203 /*SubobjectIsDesignatorContext=*/false, Index,
Douglas Gregor4c678342009-01-28 21:54:33 +00002204 StructuredList, ElementIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002205 return hadError && !prevHadError;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002206}
2207
Douglas Gregor4c678342009-01-28 21:54:33 +00002208// Get the structured initializer list for a subobject of type
2209// @p CurrentObjectType.
2210InitListExpr *
2211InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2212 QualType CurrentObjectType,
2213 InitListExpr *StructuredList,
2214 unsigned StructuredIndex,
2215 SourceRange InitRange) {
Sebastian Redl14b0c192011-09-24 17:48:00 +00002216 if (VerifyOnly)
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002217 return nullptr; // No structured list in verification-only mode.
2218 Expr *ExistingInit = nullptr;
Douglas Gregor4c678342009-01-28 21:54:33 +00002219 if (!StructuredList)
Benjamin Kramera7894162012-02-23 14:48:40 +00002220 ExistingInit = SyntacticToSemantic.lookup(IList);
Douglas Gregor4c678342009-01-28 21:54:33 +00002221 else if (StructuredIndex < StructuredList->getNumInits())
2222 ExistingInit = StructuredList->getInit(StructuredIndex);
Mike Stump1eb44332009-09-09 15:08:12 +00002223
Douglas Gregor4c678342009-01-28 21:54:33 +00002224 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2225 return Result;
2226
2227 if (ExistingInit) {
2228 // We are creating an initializer list that initializes the
2229 // subobjects of the current object, but there was already an
2230 // initialization that completely initialized the current
2231 // subobject, e.g., by a compound literal:
Mike Stump1eb44332009-09-09 15:08:12 +00002232 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002233 // struct X { int a, b; };
2234 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
Mike Stump1eb44332009-09-09 15:08:12 +00002235 //
Douglas Gregor4c678342009-01-28 21:54:33 +00002236 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2237 // designated initializer re-initializes the whole
2238 // subobject [0], overwriting previous initializers.
Mike Stump1eb44332009-09-09 15:08:12 +00002239 SemaRef.Diag(InitRange.getBegin(),
Douglas Gregored8a93d2009-03-01 17:12:46 +00002240 diag::warn_subobject_initializer_overrides)
Douglas Gregor4c678342009-01-28 21:54:33 +00002241 << InitRange;
Daniel Dunbar96a00142012-03-09 18:35:03 +00002242 SemaRef.Diag(ExistingInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002243 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002244 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002245 << ExistingInit->getSourceRange();
2246 }
2247
Mike Stump1eb44332009-09-09 15:08:12 +00002248 InitListExpr *Result
Ted Kremenek709210f2010-04-13 23:39:13 +00002249 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00002250 InitRange.getBegin(), None,
Ted Kremenekba7bc552010-02-19 01:50:18 +00002251 InitRange.getEnd());
Douglas Gregored8a93d2009-03-01 17:12:46 +00002252
Eli Friedman5c89c392012-02-23 02:25:10 +00002253 QualType ResultType = CurrentObjectType;
2254 if (!ResultType->isArrayType())
2255 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2256 Result->setType(ResultType);
Douglas Gregor4c678342009-01-28 21:54:33 +00002257
Douglas Gregorfa219202009-03-20 23:58:33 +00002258 // Pre-allocate storage for the structured initializer list.
2259 unsigned NumElements = 0;
Douglas Gregor08457732009-03-21 18:13:52 +00002260 unsigned NumInits = 0;
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002261 bool GotNumInits = false;
2262 if (!StructuredList) {
Douglas Gregor08457732009-03-21 18:13:52 +00002263 NumInits = IList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002264 GotNumInits = true;
2265 } else if (Index < IList->getNumInits()) {
2266 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
Douglas Gregor08457732009-03-21 18:13:52 +00002267 NumInits = SubList->getNumInits();
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002268 GotNumInits = true;
2269 }
Douglas Gregor08457732009-03-21 18:13:52 +00002270 }
2271
Mike Stump1eb44332009-09-09 15:08:12 +00002272 if (const ArrayType *AType
Douglas Gregorfa219202009-03-20 23:58:33 +00002273 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2274 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2275 NumElements = CAType->getSize().getZExtValue();
2276 // Simple heuristic so that we don't allocate a very large
2277 // initializer with many empty entries at the end.
Argyrios Kyrtzidisf8b17712011-04-28 18:53:55 +00002278 if (GotNumInits && NumElements > NumInits)
Douglas Gregorfa219202009-03-20 23:58:33 +00002279 NumElements = 0;
2280 }
John McCall183700f2009-09-21 23:43:11 +00002281 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
Douglas Gregorfa219202009-03-20 23:58:33 +00002282 NumElements = VType->getNumElements();
Ted Kremenek6217b802009-07-29 21:53:49 +00002283 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
Douglas Gregorfa219202009-03-20 23:58:33 +00002284 RecordDecl *RDecl = RType->getDecl();
2285 if (RDecl->isUnion())
2286 NumElements = 1;
2287 else
Stephen Hines651f13c2014-04-23 16:59:28 -07002288 NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
Douglas Gregorfa219202009-03-20 23:58:33 +00002289 }
2290
Ted Kremenek709210f2010-04-13 23:39:13 +00002291 Result->reserveInits(SemaRef.Context, NumElements);
Douglas Gregorfa219202009-03-20 23:58:33 +00002292
Douglas Gregor4c678342009-01-28 21:54:33 +00002293 // Link this new initializer list into the structured initializer
2294 // lists.
2295 if (StructuredList)
Ted Kremenek709210f2010-04-13 23:39:13 +00002296 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
Douglas Gregor4c678342009-01-28 21:54:33 +00002297 else {
2298 Result->setSyntacticForm(IList);
2299 SyntacticToSemantic[IList] = Result;
2300 }
2301
2302 return Result;
2303}
2304
2305/// Update the initializer at index @p StructuredIndex within the
2306/// structured initializer list to the value @p expr.
2307void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2308 unsigned &StructuredIndex,
2309 Expr *expr) {
2310 // No structured initializer list to update
2311 if (!StructuredList)
2312 return;
2313
Ted Kremenek709210f2010-04-13 23:39:13 +00002314 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2315 StructuredIndex, expr)) {
Douglas Gregor4c678342009-01-28 21:54:33 +00002316 // This initializer overwrites a previous initializer. Warn.
Daniel Dunbar96a00142012-03-09 18:35:03 +00002317 SemaRef.Diag(expr->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002318 diag::warn_initializer_overrides)
2319 << expr->getSourceRange();
Daniel Dunbar96a00142012-03-09 18:35:03 +00002320 SemaRef.Diag(PrevInit->getLocStart(),
Douglas Gregor4c678342009-01-28 21:54:33 +00002321 diag::note_previous_initializer)
Douglas Gregor54f07282009-01-28 23:43:32 +00002322 << /*FIXME:has side effects=*/0
Douglas Gregor4c678342009-01-28 21:54:33 +00002323 << PrevInit->getSourceRange();
2324 }
Mike Stump1eb44332009-09-09 15:08:12 +00002325
Douglas Gregor4c678342009-01-28 21:54:33 +00002326 ++StructuredIndex;
2327}
2328
Douglas Gregor05c13a32009-01-22 00:58:24 +00002329/// Check that the given Index expression is a valid array designator
Richard Smith282e7e62012-02-04 09:53:13 +00002330/// value. This is essentially just a wrapper around
Chris Lattner3bf68932009-04-25 21:59:05 +00002331/// VerifyIntegerConstantExpression that also checks for negative values
Douglas Gregor05c13a32009-01-22 00:58:24 +00002332/// and produces a reasonable diagnostic if there is a
Richard Smith282e7e62012-02-04 09:53:13 +00002333/// failure. Returns the index expression, possibly with an implicit cast
2334/// added, on success. If everything went okay, Value will receive the
2335/// value of the constant expression.
2336static ExprResult
Chris Lattner3bf68932009-04-25 21:59:05 +00002337CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
Daniel Dunbar96a00142012-03-09 18:35:03 +00002338 SourceLocation Loc = Index->getLocStart();
Douglas Gregor05c13a32009-01-22 00:58:24 +00002339
2340 // Make sure this is an integer constant expression.
Richard Smith282e7e62012-02-04 09:53:13 +00002341 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2342 if (Result.isInvalid())
2343 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002344
Chris Lattner3bf68932009-04-25 21:59:05 +00002345 if (Value.isSigned() && Value.isNegative())
2346 return S.Diag(Loc, diag::err_array_designator_negative)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002347 << Value.toString(10) << Index->getSourceRange();
2348
Douglas Gregor53d3d8e2009-01-23 21:04:18 +00002349 Value.setIsUnsigned(true);
Richard Smith282e7e62012-02-04 09:53:13 +00002350 return Result;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002351}
2352
John McCall60d7b3a2010-08-24 06:29:42 +00002353ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
Nick Lewycky7663f392010-11-20 01:29:55 +00002354 SourceLocation Loc,
2355 bool GNUSyntax,
2356 ExprResult Init) {
Douglas Gregor05c13a32009-01-22 00:58:24 +00002357 typedef DesignatedInitExpr::Designator ASTDesignator;
2358
2359 bool Invalid = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002360 SmallVector<ASTDesignator, 32> Designators;
2361 SmallVector<Expr *, 32> InitExpressions;
Douglas Gregor05c13a32009-01-22 00:58:24 +00002362
2363 // Build designators and check array designator expressions.
2364 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2365 const Designator &D = Desig.getDesignator(Idx);
2366 switch (D.getKind()) {
2367 case Designator::FieldDesignator:
Mike Stump1eb44332009-09-09 15:08:12 +00002368 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002369 D.getFieldLoc()));
2370 break;
2371
2372 case Designator::ArrayDesignator: {
2373 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2374 llvm::APSInt IndexValue;
Richard Smith282e7e62012-02-04 09:53:13 +00002375 if (!Index->isTypeDependent() && !Index->isValueDependent())
2376 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take();
2377 if (!Index)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002378 Invalid = true;
2379 else {
2380 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002381 D.getLBracketLoc(),
Douglas Gregor05c13a32009-01-22 00:58:24 +00002382 D.getRBracketLoc()));
2383 InitExpressions.push_back(Index);
2384 }
2385 break;
2386 }
2387
2388 case Designator::ArrayRangeDesignator: {
2389 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2390 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2391 llvm::APSInt StartValue;
2392 llvm::APSInt EndValue;
Douglas Gregor9ea62762009-05-21 23:17:49 +00002393 bool StartDependent = StartIndex->isTypeDependent() ||
2394 StartIndex->isValueDependent();
2395 bool EndDependent = EndIndex->isTypeDependent() ||
2396 EndIndex->isValueDependent();
Richard Smith282e7e62012-02-04 09:53:13 +00002397 if (!StartDependent)
2398 StartIndex =
2399 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take();
2400 if (!EndDependent)
2401 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take();
2402
2403 if (!StartIndex || !EndIndex)
Douglas Gregor05c13a32009-01-22 00:58:24 +00002404 Invalid = true;
Douglas Gregord6f584f2009-01-23 22:22:29 +00002405 else {
2406 // Make sure we're comparing values with the same bit width.
Douglas Gregor9ea62762009-05-21 23:17:49 +00002407 if (StartDependent || EndDependent) {
2408 // Nothing to compute.
2409 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002410 EndValue = EndValue.extend(StartValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002411 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +00002412 StartValue = StartValue.extend(EndValue.getBitWidth());
Douglas Gregord6f584f2009-01-23 22:22:29 +00002413
Douglas Gregorc4bb7bf2009-05-21 23:30:39 +00002414 if (!StartDependent && !EndDependent && EndValue < StartValue) {
Douglas Gregord6f584f2009-01-23 22:22:29 +00002415 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
Mike Stump1eb44332009-09-09 15:08:12 +00002416 << StartValue.toString(10) << EndValue.toString(10)
Douglas Gregord6f584f2009-01-23 22:22:29 +00002417 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2418 Invalid = true;
2419 } else {
2420 Designators.push_back(ASTDesignator(InitExpressions.size(),
Mike Stump1eb44332009-09-09 15:08:12 +00002421 D.getLBracketLoc(),
Douglas Gregord6f584f2009-01-23 22:22:29 +00002422 D.getEllipsisLoc(),
2423 D.getRBracketLoc()));
2424 InitExpressions.push_back(StartIndex);
2425 InitExpressions.push_back(EndIndex);
2426 }
Douglas Gregor05c13a32009-01-22 00:58:24 +00002427 }
2428 break;
2429 }
2430 }
2431 }
2432
2433 if (Invalid || Init.isInvalid())
2434 return ExprError();
2435
2436 // Clear out the expressions within the designation.
2437 Desig.ClearExprs(*this);
2438
2439 DesignatedInitExpr *DIE
Jay Foadbeaaccd2009-05-21 09:52:38 +00002440 = DesignatedInitExpr::Create(Context,
2441 Designators.data(), Designators.size(),
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00002442 InitExpressions, Loc, GNUSyntax,
2443 Init.takeAs<Expr>());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002444
David Blaikie4e4d0842012-03-11 07:00:24 +00002445 if (!getLangOpts().C99)
Douglas Gregor2d75bbd2011-01-16 16:13:16 +00002446 Diag(DIE->getLocStart(), diag::ext_designated_init)
2447 << DIE->getSourceRange();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002448
Douglas Gregor05c13a32009-01-22 00:58:24 +00002449 return Owned(DIE);
2450}
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002451
Douglas Gregor20093b42009-12-09 23:02:17 +00002452//===----------------------------------------------------------------------===//
2453// Initialization entity
2454//===----------------------------------------------------------------------===//
2455
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002456InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002457 const InitializedEntity &Parent)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002458 : Parent(&Parent), Index(Index)
Douglas Gregorcb57fb92009-12-16 06:35:08 +00002459{
Anders Carlssond3d824d2010-01-23 04:34:47 +00002460 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2461 Kind = EK_ArrayElement;
Douglas Gregord6542d82009-12-22 15:35:07 +00002462 Type = AT->getElementType();
Eli Friedman0c706c22011-09-19 23:17:44 +00002463 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
Anders Carlssond3d824d2010-01-23 04:34:47 +00002464 Kind = EK_VectorElement;
Eli Friedman0c706c22011-09-19 23:17:44 +00002465 Type = VT->getElementType();
2466 } else {
2467 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2468 assert(CT && "Unexpected type");
2469 Kind = EK_ComplexElement;
2470 Type = CT->getElementType();
Anders Carlssond3d824d2010-01-23 04:34:47 +00002471 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002472}
2473
Benjamin Kramer4c7736e2013-07-24 15:28:33 +00002474InitializedEntity
2475InitializedEntity::InitializeBase(ASTContext &Context,
2476 const CXXBaseSpecifier *Base,
2477 bool IsInheritedVirtualBase) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002478 InitializedEntity Result;
2479 Result.Kind = EK_Base;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002480 Result.Parent = nullptr;
Anders Carlsson711f34a2010-04-21 19:52:01 +00002481 Result.Base = reinterpret_cast<uintptr_t>(Base);
2482 if (IsInheritedVirtualBase)
2483 Result.Base |= 0x01;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002484
Douglas Gregord6542d82009-12-22 15:35:07 +00002485 Result.Type = Base->getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00002486 return Result;
2487}
2488
Douglas Gregor99a2e602009-12-16 01:38:02 +00002489DeclarationName InitializedEntity::getName() const {
2490 switch (getKind()) {
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002491 case EK_Parameter:
2492 case EK_Parameter_CF_Audited: {
John McCallf85e1932011-06-15 23:02:42 +00002493 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2494 return (D ? D->getDeclName() : DeclarationName());
2495 }
Douglas Gregora188ff22009-12-22 16:09:06 +00002496
2497 case EK_Variable:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002498 case EK_Member:
2499 return VariableOrMember->getDeclName();
2500
Douglas Gregor47736542012-02-15 16:57:26 +00002501 case EK_LambdaCapture:
Bill Wendling2434dcf2013-12-05 05:25:04 +00002502 return DeclarationName(Capture.VarID);
Douglas Gregor47736542012-02-15 16:57:26 +00002503
Douglas Gregor99a2e602009-12-16 01:38:02 +00002504 case EK_Result:
2505 case EK_Exception:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002506 case EK_New:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002507 case EK_Temporary:
2508 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002509 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002510 case EK_ArrayElement:
2511 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002512 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002513 case EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00002514 case EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002515 case EK_RelatedResult:
Douglas Gregor99a2e602009-12-16 01:38:02 +00002516 return DeclarationName();
2517 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002518
David Blaikie7530c032012-01-17 06:56:22 +00002519 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor99a2e602009-12-16 01:38:02 +00002520}
2521
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002522DeclaratorDecl *InitializedEntity::getDecl() const {
2523 switch (getKind()) {
2524 case EK_Variable:
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002525 case EK_Member:
2526 return VariableOrMember;
2527
John McCallf85e1932011-06-15 23:02:42 +00002528 case EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002529 case EK_Parameter_CF_Audited:
John McCallf85e1932011-06-15 23:02:42 +00002530 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2531
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002532 case EK_Result:
2533 case EK_Exception:
2534 case EK_New:
2535 case EK_Temporary:
2536 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002537 case EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00002538 case EK_ArrayElement:
2539 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002540 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002541 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002542 case EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00002543 case EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002544 case EK_RelatedResult:
Stephen Hines6bcf27b2014-05-29 04:14:42 -07002545 return nullptr;
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002546 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002547
David Blaikie7530c032012-01-17 06:56:22 +00002548 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00002549}
2550
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002551bool InitializedEntity::allowsNRVO() const {
2552 switch (getKind()) {
2553 case EK_Result:
2554 case EK_Exception:
2555 return LocAndNRVO.NRVO;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002556
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002557 case EK_Variable:
2558 case EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002559 case EK_Parameter_CF_Audited:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002560 case EK_Member:
2561 case EK_New:
2562 case EK_Temporary:
Jordan Rose2624b812013-05-06 16:48:12 +00002563 case EK_CompoundLiteralInit:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002564 case EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00002565 case EK_Delegating:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002566 case EK_ArrayElement:
2567 case EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00002568 case EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00002569 case EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00002570 case EK_LambdaCapture:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002571 case EK_RelatedResult:
Douglas Gregor3c9034c2010-05-15 00:13:29 +00002572 break;
2573 }
2574
2575 return false;
2576}
2577
Richard Smith211c8dd2013-06-05 00:46:14 +00002578unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
Richard Smitha4bb99c2013-06-12 21:51:50 +00002579 assert(getParent() != this);
Richard Smith211c8dd2013-06-05 00:46:14 +00002580 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2581 for (unsigned I = 0; I != Depth; ++I)
2582 OS << "`-";
2583
2584 switch (getKind()) {
2585 case EK_Variable: OS << "Variable"; break;
2586 case EK_Parameter: OS << "Parameter"; break;
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002587 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2588 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00002589 case EK_Result: OS << "Result"; break;
2590 case EK_Exception: OS << "Exception"; break;
2591 case EK_Member: OS << "Member"; break;
2592 case EK_New: OS << "New"; break;
2593 case EK_Temporary: OS << "Temporary"; break;
2594 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00002595 case EK_RelatedResult: OS << "RelatedResult"; break;
Richard Smith211c8dd2013-06-05 00:46:14 +00002596 case EK_Base: OS << "Base"; break;
2597 case EK_Delegating: OS << "Delegating"; break;
2598 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2599 case EK_VectorElement: OS << "VectorElement " << Index; break;
2600 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2601 case EK_BlockElement: OS << "Block"; break;
2602 case EK_LambdaCapture:
2603 OS << "LambdaCapture ";
Bill Wendling2434dcf2013-12-05 05:25:04 +00002604 OS << DeclarationName(Capture.VarID);
Richard Smith211c8dd2013-06-05 00:46:14 +00002605 break;
2606 }
2607
2608 if (Decl *D = getDecl()) {
2609 OS << " ";
2610 cast<NamedDecl>(D)->printQualifiedName(OS);
2611 }
2612
2613 OS << " '" << getType().getAsString() << "'\n";
2614
2615 return Depth + 1;
2616}
2617
2618void InitializedEntity::dump() const {
2619 dumpImpl(llvm::errs());
2620}
2621
Douglas Gregor20093b42009-12-09 23:02:17 +00002622//===----------------------------------------------------------------------===//
2623// Initialization sequence
2624//===----------------------------------------------------------------------===//
2625
2626void InitializationSequence::Step::Destroy() {
2627 switch (Kind) {
2628 case SK_ResolveAddressOfOverloadedFunction:
2629 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002630 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002631 case SK_CastDerivedToBaseLValue:
2632 case SK_BindReference:
2633 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00002634 case SK_ExtraneousCopyToTemporary:
Douglas Gregor20093b42009-12-09 23:02:17 +00002635 case SK_UserConversion:
2636 case SK_QualificationConversionRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002637 case SK_QualificationConversionXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00002638 case SK_QualificationConversionLValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00002639 case SK_LValueToRValue:
Douglas Gregord87b61f2009-12-10 17:56:55 +00002640 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002641 case SK_ListConstructorCall:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002642 case SK_UnwrapInitList:
2643 case SK_RewrapInitList:
Douglas Gregor51c56d62009-12-14 20:49:26 +00002644 case SK_ConstructorInitialization:
Douglas Gregor71d17402009-12-15 00:01:57 +00002645 case SK_ZeroInitialization:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002646 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002647 case SK_StringInit:
Douglas Gregor569c3162010-08-07 11:51:51 +00002648 case SK_ObjCObjectConversion:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002649 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00002650 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00002651 case SK_PassByIndirectCopyRestore:
2652 case SK_PassByIndirectRestore:
2653 case SK_ProduceObjCObject:
Sebastian Redl2b916b82012-01-17 22:49:42 +00002654 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00002655 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00002656 case SK_OCLZeroEvent:
Douglas Gregor20093b42009-12-09 23:02:17 +00002657 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002658
Douglas Gregor20093b42009-12-09 23:02:17 +00002659 case SK_ConversionSequence:
Richard Smith13b228d2013-09-21 21:19:19 +00002660 case SK_ConversionSequenceNoNarrowing:
Douglas Gregor20093b42009-12-09 23:02:17 +00002661 delete ICS;
2662 }
2663}
2664
Douglas Gregorb70cf442010-03-26 20:14:36 +00002665bool InitializationSequence::isDirectReferenceBinding() const {
Sebastian Redl3b802322011-07-14 19:07:55 +00002666 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
Douglas Gregorb70cf442010-03-26 20:14:36 +00002667}
2668
2669bool InitializationSequence::isAmbiguous() const {
Sebastian Redld695d6b2011-06-05 13:59:05 +00002670 if (!Failed())
Douglas Gregorb70cf442010-03-26 20:14:36 +00002671 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002672
Douglas Gregorb70cf442010-03-26 20:14:36 +00002673 switch (getFailureKind()) {
2674 case FK_TooManyInitsForReference:
2675 case FK_ArrayNeedsInitList:
2676 case FK_ArrayNeedsInitListOrStringLiteral:
Hans Wennborg0ff50742013-05-15 11:03:04 +00002677 case FK_ArrayNeedsInitListOrWideStringLiteral:
2678 case FK_NarrowStringIntoWideCharArray:
2679 case FK_WideStringIntoCharArray:
2680 case FK_IncompatWideStringIntoWideChar:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002681 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2682 case FK_NonConstLValueReferenceBindingToTemporary:
2683 case FK_NonConstLValueReferenceBindingToUnrelated:
2684 case FK_RValueReferenceBindingToLValue:
2685 case FK_ReferenceInitDropsQualifiers:
2686 case FK_ReferenceInitFailed:
2687 case FK_ConversionFailed:
John Wiegley429bb272011-04-08 18:41:53 +00002688 case FK_ConversionFromPropertyFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002689 case FK_TooManyInitsForScalar:
2690 case FK_ReferenceBindingToInitList:
2691 case FK_InitListBadDestinationType:
2692 case FK_DefaultInitOfConst:
Douglas Gregor72a43bb2010-05-20 22:12:02 +00002693 case FK_Incomplete:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002694 case FK_ArrayTypeMismatch:
2695 case FK_NonConstantArrayInit:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00002696 case FK_ListInitializationFailed:
John McCall73076432012-01-05 00:13:19 +00002697 case FK_VariableLengthArrayHasInitializer:
John McCall5acb0c92011-10-17 18:40:02 +00002698 case FK_PlaceholderType:
Sebastian Redl70e24fc2012-04-01 19:54:59 +00002699 case FK_ExplicitConstructor:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002700 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002701
Douglas Gregorb70cf442010-03-26 20:14:36 +00002702 case FK_ReferenceInitOverloadFailed:
2703 case FK_UserConversionOverloadFailed:
2704 case FK_ConstructorOverloadFailed:
Sebastian Redlcf15cef2011-12-22 18:58:38 +00002705 case FK_ListConstructorOverloadFailed:
Douglas Gregorb70cf442010-03-26 20:14:36 +00002706 return FailedOverloadResult == OR_Ambiguous;
2707 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002708
David Blaikie7530c032012-01-17 06:56:22 +00002709 llvm_unreachable("Invalid EntityKind!");
Douglas Gregorb70cf442010-03-26 20:14:36 +00002710}
2711
Douglas Gregord6e44a32010-04-16 22:09:46 +00002712bool InitializationSequence::isConstructorInitialization() const {
2713 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2714}
2715
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002716void
2717InitializationSequence
2718::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2719 DeclAccessPair Found,
2720 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002721 Step S;
2722 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2723 S.Type = Function->getType();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002724 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002725 S.Function.Function = Function;
John McCall6bb80172010-03-30 21:47:33 +00002726 S.Function.FoundDecl = Found;
Douglas Gregor20093b42009-12-09 23:02:17 +00002727 Steps.push_back(S);
2728}
2729
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002730void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
John McCall5baba9d2010-08-25 10:28:54 +00002731 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002732 Step S;
John McCall5baba9d2010-08-25 10:28:54 +00002733 switch (VK) {
2734 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2735 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2736 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002737 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002738 S.Type = BaseType;
2739 Steps.push_back(S);
2740}
2741
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002742void InitializationSequence::AddReferenceBindingStep(QualType T,
Douglas Gregor20093b42009-12-09 23:02:17 +00002743 bool BindingTemporary) {
2744 Step S;
2745 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2746 S.Type = T;
2747 Steps.push_back(S);
2748}
2749
Douglas Gregor523d46a2010-04-18 07:40:54 +00002750void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2751 Step S;
2752 S.Kind = SK_ExtraneousCopyToTemporary;
2753 S.Type = T;
2754 Steps.push_back(S);
2755}
2756
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002757void
2758InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2759 DeclAccessPair FoundDecl,
2760 QualType T,
2761 bool HadMultipleCandidates) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002762 Step S;
2763 S.Kind = SK_UserConversion;
Eli Friedman03981012009-12-11 02:42:07 +00002764 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002765 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002766 S.Function.Function = Function;
2767 S.Function.FoundDecl = FoundDecl;
Douglas Gregor20093b42009-12-09 23:02:17 +00002768 Steps.push_back(S);
2769}
2770
2771void InitializationSequence::AddQualificationConversionStep(QualType Ty,
John McCall5baba9d2010-08-25 10:28:54 +00002772 ExprValueKind VK) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002773 Step S;
John McCall38a4ffe2010-08-26 16:36:35 +00002774 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
John McCall5baba9d2010-08-25 10:28:54 +00002775 switch (VK) {
2776 case VK_RValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002777 S.Kind = SK_QualificationConversionRValue;
2778 break;
John McCall5baba9d2010-08-25 10:28:54 +00002779 case VK_XValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002780 S.Kind = SK_QualificationConversionXValue;
2781 break;
John McCall5baba9d2010-08-25 10:28:54 +00002782 case VK_LValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00002783 S.Kind = SK_QualificationConversionLValue;
2784 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00002785 }
Douglas Gregor20093b42009-12-09 23:02:17 +00002786 S.Type = Ty;
2787 Steps.push_back(S);
2788}
2789
Jordan Rose1fd1e282013-04-11 00:58:58 +00002790void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
2791 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
2792
2793 Step S;
2794 S.Kind = SK_LValueToRValue;
2795 S.Type = Ty;
2796 Steps.push_back(S);
2797}
2798
Douglas Gregor20093b42009-12-09 23:02:17 +00002799void InitializationSequence::AddConversionSequenceStep(
Richard Smith13b228d2013-09-21 21:19:19 +00002800 const ImplicitConversionSequence &ICS, QualType T,
2801 bool TopLevelOfInitList) {
Douglas Gregor20093b42009-12-09 23:02:17 +00002802 Step S;
Richard Smith13b228d2013-09-21 21:19:19 +00002803 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
2804 : SK_ConversionSequence;
Douglas Gregor20093b42009-12-09 23:02:17 +00002805 S.Type = T;
2806 S.ICS = new ImplicitConversionSequence(ICS);
2807 Steps.push_back(S);
2808}
2809
Douglas Gregord87b61f2009-12-10 17:56:55 +00002810void InitializationSequence::AddListInitializationStep(QualType T) {
2811 Step S;
2812 S.Kind = SK_ListInitialization;
2813 S.Type = T;
2814 Steps.push_back(S);
2815}
2816
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002817void
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002818InitializationSequence
2819::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2820 AccessSpecifier Access,
2821 QualType T,
Sebastian Redl10f04a62011-12-22 14:44:04 +00002822 bool HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002823 bool FromInitList, bool AsInitList) {
Douglas Gregor51c56d62009-12-14 20:49:26 +00002824 Step S;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00002825 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall
2826 : SK_ConstructorInitialization;
Douglas Gregor51c56d62009-12-14 20:49:26 +00002827 S.Type = T;
Abramo Bagnara22c107b2011-11-19 11:44:21 +00002828 S.Function.HadMultipleCandidates = HadMultipleCandidates;
John McCall9aa472c2010-03-19 07:35:19 +00002829 S.Function.Function = Constructor;
2830 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
Douglas Gregor51c56d62009-12-14 20:49:26 +00002831 Steps.push_back(S);
2832}
2833
Douglas Gregor71d17402009-12-15 00:01:57 +00002834void InitializationSequence::AddZeroInitializationStep(QualType T) {
2835 Step S;
2836 S.Kind = SK_ZeroInitialization;
2837 S.Type = T;
2838 Steps.push_back(S);
2839}
2840
Douglas Gregor18ef5e22009-12-18 05:02:21 +00002841void InitializationSequence::AddCAssignmentStep(QualType T) {
2842 Step S;
2843 S.Kind = SK_CAssignment;
2844 S.Type = T;
2845 Steps.push_back(S);
2846}
2847
Eli Friedmancfdc81a2009-12-19 08:11:05 +00002848void InitializationSequence::AddStringInitStep(QualType T) {
2849 Step S;
2850 S.Kind = SK_StringInit;
2851 S.Type = T;
2852 Steps.push_back(S);
2853}
2854
Douglas Gregor569c3162010-08-07 11:51:51 +00002855void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2856 Step S;
2857 S.Kind = SK_ObjCObjectConversion;
2858 S.Type = T;
2859 Steps.push_back(S);
2860}
2861
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00002862void InitializationSequence::AddArrayInitStep(QualType T) {
2863 Step S;
2864 S.Kind = SK_ArrayInit;
2865 S.Type = T;
2866 Steps.push_back(S);
2867}
2868
Richard Smith0f163e92012-02-15 22:38:09 +00002869void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2870 Step S;
2871 S.Kind = SK_ParenthesizedArrayInit;
2872 S.Type = T;
2873 Steps.push_back(S);
2874}
2875
John McCallf85e1932011-06-15 23:02:42 +00002876void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2877 bool shouldCopy) {
2878 Step s;
2879 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2880 : SK_PassByIndirectRestore);
2881 s.Type = type;
2882 Steps.push_back(s);
2883}
2884
2885void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2886 Step S;
2887 S.Kind = SK_ProduceObjCObject;
2888 S.Type = T;
2889 Steps.push_back(S);
2890}
2891
Sebastian Redl2b916b82012-01-17 22:49:42 +00002892void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2893 Step S;
2894 S.Kind = SK_StdInitializerList;
2895 S.Type = T;
2896 Steps.push_back(S);
2897}
2898
Guy Benyei21f18c42013-02-07 10:55:47 +00002899void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
2900 Step S;
2901 S.Kind = SK_OCLSamplerInit;
2902 S.Type = T;
2903 Steps.push_back(S);
2904}
2905
Guy Benyeie6b9d802013-01-20 12:31:11 +00002906void InitializationSequence::AddOCLZeroEventStep(QualType T) {
2907 Step S;
2908 S.Kind = SK_OCLZeroEvent;
2909 S.Type = T;
2910 Steps.push_back(S);
2911}
2912
Sebastian Redl13dc8f92011-11-27 16:50:07 +00002913void InitializationSequence::RewrapReferenceInitList(QualType T,
2914 InitListExpr *Syntactic) {
2915 assert(Syntactic->getNumInits() == 1 &&
2916 "Can only rewrap trivial init lists.");
2917 Step S;
2918 S.Kind = SK_UnwrapInitList;
2919 S.Type = Syntactic->getInit(0)->getType();
2920 Steps.insert(Steps.begin(), S);
2921
2922 S.Kind = SK_RewrapInitList;
2923 S.Type = T;
2924 S.WrappingSyntacticList = Syntactic;
2925 Steps.push_back(S);
2926}
2927
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002928void InitializationSequence::SetOverloadFailure(FailureKind Failure,
Douglas Gregor20093b42009-12-09 23:02:17 +00002929 OverloadingResult Result) {
Sebastian Redl7491c492011-06-05 13:59:11 +00002930 setSequenceKind(FailedSequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00002931 this->Failure = Failure;
2932 this->FailedOverloadResult = Result;
2933}
2934
2935//===----------------------------------------------------------------------===//
2936// Attempt initialization
2937//===----------------------------------------------------------------------===//
2938
John McCallf85e1932011-06-15 23:02:42 +00002939static void MaybeProduceObjCObject(Sema &S,
2940 InitializationSequence &Sequence,
2941 const InitializedEntity &Entity) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002942 if (!S.getLangOpts().ObjCAutoRefCount) return;
John McCallf85e1932011-06-15 23:02:42 +00002943
2944 /// When initializing a parameter, produce the value if it's marked
2945 /// __attribute__((ns_consumed)).
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00002946 if (Entity.isParameterKind()) {
John McCallf85e1932011-06-15 23:02:42 +00002947 if (!Entity.isParameterConsumed())
2948 return;
2949
2950 assert(Entity.getType()->isObjCRetainableType() &&
2951 "consuming an object of unretainable type?");
2952 Sequence.AddProduceObjCObjectStep(Entity.getType());
2953
2954 /// When initializing a return value, if the return type is a
2955 /// retainable type, then returns need to immediately retain the
2956 /// object. If an autorelease is required, it will be done at the
2957 /// last instant.
2958 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
2959 if (!Entity.getType()->isObjCRetainableType())
2960 return;
2961
2962 Sequence.AddProduceObjCObjectStep(Entity.getType());
2963 }
2964}
2965
Richard Smith7c3e6152013-06-12 22:31:48 +00002966static void TryListInitialization(Sema &S,
2967 const InitializedEntity &Entity,
2968 const InitializationKind &Kind,
2969 InitListExpr *InitList,
2970 InitializationSequence &Sequence);
2971
Richard Smithf4bb8d02012-07-05 08:39:21 +00002972/// \brief When initializing from init list via constructor, handle
2973/// initialization of an object of type std::initializer_list<T>.
Sebastian Redl10f04a62011-12-22 14:44:04 +00002974///
Richard Smithf4bb8d02012-07-05 08:39:21 +00002975/// \return true if we have handled initialization of an object of type
2976/// std::initializer_list<T>, false otherwise.
2977static bool TryInitializerListConstruction(Sema &S,
2978 InitListExpr *List,
2979 QualType DestType,
2980 InitializationSequence &Sequence) {
2981 QualType E;
2982 if (!S.isStdInitializerList(DestType, &E))
Richard Smith1d0c9a82012-02-14 21:14:13 +00002983 return false;
2984
Richard Smith7c3e6152013-06-12 22:31:48 +00002985 if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
2986 Sequence.setIncompleteTypeFailure(E);
2987 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00002988 }
Richard Smith7c3e6152013-06-12 22:31:48 +00002989
2990 // Try initializing a temporary array from the init list.
2991 QualType ArrayType = S.Context.getConstantArrayType(
2992 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
2993 List->getNumInits()),
2994 clang::ArrayType::Normal, 0);
2995 InitializedEntity HiddenArray =
2996 InitializedEntity::InitializeTemporary(ArrayType);
2997 InitializationKind Kind =
2998 InitializationKind::CreateDirectList(List->getExprLoc());
2999 TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3000 if (Sequence)
3001 Sequence.AddStdInitializerListConstructionStep(DestType);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003002 return true;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003003}
3004
Sebastian Redl96715b22012-02-04 21:27:39 +00003005static OverloadingResult
3006ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003007 MultiExprArg Args,
Sebastian Redl96715b22012-02-04 21:27:39 +00003008 OverloadCandidateSet &CandidateSet,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003009 ArrayRef<NamedDecl *> Ctors,
Sebastian Redl96715b22012-02-04 21:27:39 +00003010 OverloadCandidateSet::iterator &Best,
3011 bool CopyInitializing, bool AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003012 bool OnlyListConstructors, bool InitListSyntax) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003013 CandidateSet.clear();
3014
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003015 for (ArrayRef<NamedDecl *>::iterator
3016 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003017 NamedDecl *D = *Con;
3018 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3019 bool SuppressUserConversions = false;
3020
3021 // Find the constructor (which may be a template).
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003022 CXXConstructorDecl *Constructor = nullptr;
Sebastian Redl96715b22012-02-04 21:27:39 +00003023 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3024 if (ConstructorTmpl)
3025 Constructor = cast<CXXConstructorDecl>(
3026 ConstructorTmpl->getTemplatedDecl());
3027 else {
3028 Constructor = cast<CXXConstructorDecl>(D);
3029
Richard Smith867521c2013-09-21 21:23:47 +00003030 // C++11 [over.best.ics]p4:
3031 // However, when considering the argument of a constructor or
3032 // user-defined conversion function that is a candidate:
3033 // -- by 13.3.1.3 when invoked for the copying/moving of a temporary
3034 // in the second step of a class copy-initialization,
3035 // -- by 13.3.1.7 when passing the initializer list as a single
3036 // argument or when the initializer list has exactly one elementand
3037 // a conversion to some class X or reference to (possibly
3038 // cv-qualified) X is considered for the first parameter of a
3039 // constructor of X, or
3040 // -- by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases,
3041 // only standard conversion sequences and ellipsis conversion sequences
3042 // are considered.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003043 if ((CopyInitializing || (InitListSyntax && Args.size() == 1)) &&
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003044 Constructor->isCopyOrMoveConstructor())
Sebastian Redl96715b22012-02-04 21:27:39 +00003045 SuppressUserConversions = true;
3046 }
3047
3048 if (!Constructor->isInvalidDecl() &&
3049 (AllowExplicit || !Constructor->isExplicit()) &&
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003050 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
Sebastian Redl96715b22012-02-04 21:27:39 +00003051 if (ConstructorTmpl)
3052 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003053 /*ExplicitArgs*/ nullptr, Args,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003054 CandidateSet, SuppressUserConversions);
Douglas Gregored878af2012-02-24 23:56:31 +00003055 else {
3056 // C++ [over.match.copy]p1:
3057 // - When initializing a temporary to be bound to the first parameter
3058 // of a constructor that takes a reference to possibly cv-qualified
3059 // T as its first argument, called with a single argument in the
3060 // context of direct-initialization, explicit conversion functions
3061 // are also considered.
3062 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003063 Args.size() == 1 &&
Douglas Gregored878af2012-02-24 23:56:31 +00003064 Constructor->isCopyOrMoveConstructor();
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003065 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
Douglas Gregored878af2012-02-24 23:56:31 +00003066 SuppressUserConversions,
3067 /*PartialOverloading=*/false,
3068 /*AllowExplicit=*/AllowExplicitConv);
3069 }
Sebastian Redl96715b22012-02-04 21:27:39 +00003070 }
3071 }
3072
3073 // Perform overload resolution and return the result.
3074 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3075}
3076
Sebastian Redl10f04a62011-12-22 14:44:04 +00003077/// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3078/// enumerates the constructors of the initialized entity and performs overload
3079/// resolution to select the best.
Sebastian Redl08ae3692012-02-04 21:27:33 +00003080/// If InitListSyntax is true, this is list-initialization of a non-aggregate
Sebastian Redl10f04a62011-12-22 14:44:04 +00003081/// class type.
3082static void TryConstructorInitialization(Sema &S,
3083 const InitializedEntity &Entity,
3084 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003085 MultiExprArg Args, QualType DestType,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003086 InitializationSequence &Sequence,
Sebastian Redl08ae3692012-02-04 21:27:33 +00003087 bool InitListSyntax = false) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003088 assert((!InitListSyntax || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
Sebastian Redl08ae3692012-02-04 21:27:33 +00003089 "InitListSyntax must come with a single initializer list argument.");
3090
Sebastian Redl10f04a62011-12-22 14:44:04 +00003091 // The type we're constructing needs to be complete.
3092 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003093 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redl96715b22012-02-04 21:27:39 +00003094 return;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003095 }
3096
3097 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3098 assert(DestRecordType && "Constructor initialization requires record type");
3099 CXXRecordDecl *DestRecordDecl
3100 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3101
Sebastian Redl96715b22012-02-04 21:27:39 +00003102 // Build the candidate set directly in the initialization sequence
3103 // structure, so that it will persist if we fail.
3104 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3105
3106 // Determine whether we are allowed to call explicit constructors or
3107 // explicit conversion operators.
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003108 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003109 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
Sebastian Redl08ae3692012-02-04 21:27:33 +00003110
Sebastian Redl10f04a62011-12-22 14:44:04 +00003111 // - Otherwise, if T is a class type, constructors are considered. The
3112 // applicable constructors are enumerated, and the best one is chosen
3113 // through overload resolution.
David Blaikie3bc93e32012-12-19 00:45:41 +00003114 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003115 // The container holding the constructors can under certain conditions
3116 // be changed while iterating (e.g. because of deserialization).
3117 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003118 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Sebastian Redl10f04a62011-12-22 14:44:04 +00003119
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003120 OverloadingResult Result = OR_No_Viable_Function;
Sebastian Redl10f04a62011-12-22 14:44:04 +00003121 OverloadCandidateSet::iterator Best;
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003122 bool AsInitializerList = false;
3123
3124 // C++11 [over.match.list]p1:
3125 // When objects of non-aggregate type T are list-initialized, overload
3126 // resolution selects the constructor in two phases:
3127 // - Initially, the candidate functions are the initializer-list
3128 // constructors of the class T and the argument list consists of the
3129 // initializer list as a single argument.
3130 if (InitListSyntax) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003131 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003132 AsInitializerList = true;
Richard Smithf4bb8d02012-07-05 08:39:21 +00003133
3134 // If the initializer list has no elements and T has a default constructor,
3135 // the first phase is omitted.
Richard Smithe5411b72012-12-01 02:35:44 +00003136 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003137 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003138 CandidateSet, Ctors, Best,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003139 CopyInitialization, AllowExplicit,
3140 /*OnlyListConstructor=*/true,
3141 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003142
3143 // Time to unwrap the init list.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003144 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003145 }
3146
3147 // C++11 [over.match.list]p1:
3148 // - If no viable initializer-list constructor is found, overload resolution
3149 // is performed again, where the candidate functions are all the
Richard Smithf4bb8d02012-07-05 08:39:21 +00003150 // constructors of the class T and the argument list consists of the
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003151 // elements of the initializer list.
3152 if (Result == OR_No_Viable_Function) {
3153 AsInitializerList = false;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003154 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003155 CandidateSet, Ctors, Best,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003156 CopyInitialization, AllowExplicit,
Sebastian Redl51ad9cd2012-02-29 12:47:43 +00003157 /*OnlyListConstructors=*/false,
3158 InitListSyntax);
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003159 }
3160 if (Result) {
Sebastian Redl08ae3692012-02-04 21:27:33 +00003161 Sequence.SetOverloadFailure(InitListSyntax ?
Sebastian Redlcf15cef2011-12-22 18:58:38 +00003162 InitializationSequence::FK_ListConstructorOverloadFailed :
3163 InitializationSequence::FK_ConstructorOverloadFailed,
Sebastian Redl10f04a62011-12-22 14:44:04 +00003164 Result);
3165 return;
3166 }
3167
Richard Smithf4bb8d02012-07-05 08:39:21 +00003168 // C++11 [dcl.init]p6:
Sebastian Redl10f04a62011-12-22 14:44:04 +00003169 // If a program calls for the default initialization of an object
3170 // of a const-qualified type T, T shall be a class type with a
3171 // user-provided default constructor.
3172 if (Kind.getKind() == InitializationKind::IK_Default &&
3173 Entity.getType().isConstQualified() &&
Aaron Ballman51217812012-07-31 22:40:31 +00003174 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00003175 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3176 return;
3177 }
3178
Sebastian Redl70e24fc2012-04-01 19:54:59 +00003179 // C++11 [over.match.list]p1:
3180 // In copy-list-initialization, if an explicit constructor is chosen, the
3181 // initializer is ill-formed.
3182 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3183 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3184 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3185 return;
3186 }
3187
Sebastian Redl10f04a62011-12-22 14:44:04 +00003188 // Add the constructor initialization step. Any cv-qualification conversion is
3189 // subsumed by the initialization.
3190 bool HadMultipleCandidates = (CandidateSet.size() > 1);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003191 Sequence.AddConstructorInitializationStep(CtorDecl,
3192 Best->FoundDecl.getAccess(),
3193 DestType, HadMultipleCandidates,
Sebastian Redl6cd03db2012-02-04 21:27:47 +00003194 InitListSyntax, AsInitializerList);
Sebastian Redl10f04a62011-12-22 14:44:04 +00003195}
3196
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003197static bool
3198ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3199 Expr *Initializer,
3200 QualType &SourceType,
3201 QualType &UnqualifiedSourceType,
3202 QualType UnqualifiedTargetType,
3203 InitializationSequence &Sequence) {
3204 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3205 S.Context.OverloadTy) {
3206 DeclAccessPair Found;
3207 bool HadMultipleCandidates = false;
3208 if (FunctionDecl *Fn
3209 = S.ResolveAddressOfOverloadedFunction(Initializer,
3210 UnqualifiedTargetType,
3211 false, Found,
3212 &HadMultipleCandidates)) {
3213 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3214 HadMultipleCandidates);
3215 SourceType = Fn->getType();
3216 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3217 } else if (!UnqualifiedTargetType->isRecordType()) {
3218 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3219 return true;
3220 }
3221 }
3222 return false;
3223}
3224
3225static void TryReferenceInitializationCore(Sema &S,
3226 const InitializedEntity &Entity,
3227 const InitializationKind &Kind,
3228 Expr *Initializer,
3229 QualType cv1T1, QualType T1,
3230 Qualifiers T1Quals,
3231 QualType cv2T2, QualType T2,
3232 Qualifiers T2Quals,
3233 InitializationSequence &Sequence);
3234
Richard Smithf4bb8d02012-07-05 08:39:21 +00003235static void TryValueInitialization(Sema &S,
3236 const InitializedEntity &Entity,
3237 const InitializationKind &Kind,
3238 InitializationSequence &Sequence,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003239 InitListExpr *InitList = nullptr);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003240
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003241/// \brief Attempt list initialization of a reference.
3242static void TryReferenceListInitialization(Sema &S,
3243 const InitializedEntity &Entity,
3244 const InitializationKind &Kind,
3245 InitListExpr *InitList,
Richard Smithb6e38082013-06-08 00:02:08 +00003246 InitializationSequence &Sequence) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003247 // First, catch C++03 where this isn't possible.
Richard Smith80ad52f2013-01-02 11:42:31 +00003248 if (!S.getLangOpts().CPlusPlus11) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003249 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3250 return;
3251 }
3252
3253 QualType DestType = Entity.getType();
3254 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3255 Qualifiers T1Quals;
3256 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3257
3258 // Reference initialization via an initializer list works thus:
3259 // If the initializer list consists of a single element that is
3260 // reference-related to the referenced type, bind directly to that element
3261 // (possibly creating temporaries).
3262 // Otherwise, initialize a temporary with the initializer list and
3263 // bind to that.
3264 if (InitList->getNumInits() == 1) {
3265 Expr *Initializer = InitList->getInit(0);
3266 QualType cv2T2 = Initializer->getType();
3267 Qualifiers T2Quals;
3268 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3269
3270 // If this fails, creating a temporary wouldn't work either.
3271 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3272 T1, Sequence))
3273 return;
3274
3275 SourceLocation DeclLoc = Initializer->getLocStart();
3276 bool dummy1, dummy2, dummy3;
3277 Sema::ReferenceCompareResult RefRelationship
3278 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3279 dummy2, dummy3);
3280 if (RefRelationship >= Sema::Ref_Related) {
3281 // Try to bind the reference here.
3282 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3283 T1Quals, cv2T2, T2, T2Quals, Sequence);
3284 if (Sequence)
3285 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3286 return;
3287 }
Richard Smith02d65ee2013-01-15 07:58:29 +00003288
3289 // Update the initializer if we've resolved an overloaded function.
3290 if (Sequence.step_begin() != Sequence.step_end())
3291 Sequence.RewrapReferenceInitList(cv1T1, InitList);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003292 }
3293
3294 // Not reference-related. Create a temporary and bind to that.
3295 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3296
3297 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3298 if (Sequence) {
3299 if (DestType->isRValueReferenceType() ||
3300 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3301 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3302 else
3303 Sequence.SetFailed(
3304 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3305 }
3306}
3307
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003308/// \brief Attempt list initialization (C++0x [dcl.init.list])
3309static void TryListInitialization(Sema &S,
3310 const InitializedEntity &Entity,
3311 const InitializationKind &Kind,
3312 InitListExpr *InitList,
3313 InitializationSequence &Sequence) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003314 QualType DestType = Entity.getType();
3315
Sebastian Redl14b0c192011-09-24 17:48:00 +00003316 // C++ doesn't allow scalar initialization with more than one argument.
3317 // But C99 complex numbers are scalars and it makes sense there.
David Blaikie4e4d0842012-03-11 07:00:24 +00003318 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
Sebastian Redl14b0c192011-09-24 17:48:00 +00003319 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3320 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3321 return;
3322 }
Sebastian Redl14b0c192011-09-24 17:48:00 +00003323 if (DestType->isReferenceType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003324 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003325 return;
Sebastian Redl14b0c192011-09-24 17:48:00 +00003326 }
Sebastian Redld2231c92012-02-19 12:27:43 +00003327 if (DestType->isRecordType()) {
Douglas Gregord10099e2012-05-04 16:32:21 +00003328 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
Douglas Gregor69a30b82012-04-10 20:43:46 +00003329 Sequence.setIncompleteTypeFailure(DestType);
Sebastian Redld2231c92012-02-19 12:27:43 +00003330 return;
3331 }
3332
Richard Smithf4bb8d02012-07-05 08:39:21 +00003333 // C++11 [dcl.init.list]p3:
3334 // - If T is an aggregate, aggregate initialization is performed.
Sebastian Redld2231c92012-02-19 12:27:43 +00003335 if (!DestType->isAggregateType()) {
Richard Smith80ad52f2013-01-02 11:42:31 +00003336 if (S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003337 // - Otherwise, if the initializer list has no elements and T is a
3338 // class type with a default constructor, the object is
3339 // value-initialized.
3340 if (InitList->getNumInits() == 0) {
3341 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
Richard Smithe5411b72012-12-01 02:35:44 +00003342 if (RD->hasDefaultConstructor()) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003343 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3344 return;
3345 }
3346 }
3347
3348 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3349 // an initializer_list object constructed [...]
3350 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3351 return;
3352
3353 // - Otherwise, if T is a class type, constructors are considered.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003354 Expr *InitListAsExpr = InitList;
3355 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003356 Sequence, /*InitListSyntax*/true);
Sebastian Redld2231c92012-02-19 12:27:43 +00003357 } else
3358 Sequence.SetFailed(
3359 InitializationSequence::FK_InitListBadDestinationType);
3360 return;
3361 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003362 }
Richard Smithb390e492013-09-21 21:55:46 +00003363 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3364 InitList->getNumInits() == 1 &&
3365 InitList->getInit(0)->getType()->isRecordType()) {
3366 // - Otherwise, if the initializer list has a single element of type E
3367 // [...references are handled above...], the object or reference is
3368 // initialized from that element; if a narrowing conversion is required
3369 // to convert the element to T, the program is ill-formed.
3370 //
3371 // Per core-24034, this is direct-initialization if we were performing
3372 // direct-list-initialization and copy-initialization otherwise.
3373 // We can't use InitListChecker for this, because it always performs
3374 // copy-initialization. This only matters if we might use an 'explicit'
3375 // conversion operator, so we only need to handle the cases where the source
3376 // is of record type.
3377 InitializationKind SubKind =
3378 Kind.getKind() == InitializationKind::IK_DirectList
3379 ? InitializationKind::CreateDirect(Kind.getLocation(),
3380 InitList->getLBraceLoc(),
3381 InitList->getRBraceLoc())
3382 : Kind;
3383 Expr *SubInit[1] = { InitList->getInit(0) };
3384 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3385 /*TopLevelOfInitList*/true);
3386 if (Sequence)
3387 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3388 return;
3389 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003390
Sebastian Redl14b0c192011-09-24 17:48:00 +00003391 InitListChecker CheckInitList(S, Entity, InitList,
Richard Smith40cba902013-06-06 11:41:05 +00003392 DestType, /*VerifyOnly=*/true);
Sebastian Redl14b0c192011-09-24 17:48:00 +00003393 if (CheckInitList.HadError()) {
3394 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3395 return;
3396 }
3397
3398 // Add the list initialization step with the built init list.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00003399 Sequence.AddListInitializationStep(DestType);
3400}
Douglas Gregor20093b42009-12-09 23:02:17 +00003401
3402/// \brief Try a reference initialization that involves calling a conversion
3403/// function.
Douglas Gregor20093b42009-12-09 23:02:17 +00003404static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3405 const InitializedEntity &Entity,
3406 const InitializationKind &Kind,
Douglas Gregored878af2012-02-24 23:56:31 +00003407 Expr *Initializer,
3408 bool AllowRValues,
Douglas Gregor20093b42009-12-09 23:02:17 +00003409 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003410 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003411 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3412 QualType T1 = cv1T1.getUnqualifiedType();
3413 QualType cv2T2 = Initializer->getType();
3414 QualType T2 = cv2T2.getUnqualifiedType();
3415
3416 bool DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003417 bool ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003418 bool ObjCLifetimeConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003419 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
Douglas Gregor569c3162010-08-07 11:51:51 +00003420 T1, T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003421 ObjCConversion,
3422 ObjCLifetimeConversion) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003423 "Must have incompatible references when binding via conversion");
Chandler Carruth60cfcec2009-12-13 01:37:04 +00003424 (void)DerivedToBase;
Douglas Gregor569c3162010-08-07 11:51:51 +00003425 (void)ObjCConversion;
John McCallf85e1932011-06-15 23:02:42 +00003426 (void)ObjCLifetimeConversion;
3427
Douglas Gregor20093b42009-12-09 23:02:17 +00003428 // Build the candidate set directly in the initialization sequence
3429 // structure, so that it will persist if we fail.
3430 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3431 CandidateSet.clear();
3432
3433 // Determine whether we are allowed to call explicit constructors or
3434 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00003435 bool AllowExplicit = Kind.AllowExplicit();
Richard Smith867521c2013-09-21 21:23:47 +00003436 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3437
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003438 const RecordType *T1RecordType = nullptr;
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003439 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3440 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003441 // The type we're converting to is a class type. Enumerate its constructors
3442 // to see if there is a suitable conversion.
3443 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
John McCall572fc622010-08-17 07:23:57 +00003444
David Blaikie3bc93e32012-12-19 00:45:41 +00003445 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003446 // The container holding the constructors can under certain conditions
3447 // be changed while iterating (e.g. because of deserialization).
3448 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00003449 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00003450 for (SmallVectorImpl<NamedDecl *>::iterator
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00003451 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3452 NamedDecl *D = *CI;
John McCall9aa472c2010-03-19 07:35:19 +00003453 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3454
Douglas Gregor20093b42009-12-09 23:02:17 +00003455 // Find the constructor (which may be a template).
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003456 CXXConstructorDecl *Constructor = nullptr;
John McCall9aa472c2010-03-19 07:35:19 +00003457 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor20093b42009-12-09 23:02:17 +00003458 if (ConstructorTmpl)
3459 Constructor = cast<CXXConstructorDecl>(
3460 ConstructorTmpl->getTemplatedDecl());
3461 else
John McCall9aa472c2010-03-19 07:35:19 +00003462 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003463
Douglas Gregor20093b42009-12-09 23:02:17 +00003464 if (!Constructor->isInvalidDecl() &&
3465 Constructor->isConvertingConstructor(AllowExplicit)) {
3466 if (ConstructorTmpl)
John McCall9aa472c2010-03-19 07:35:19 +00003467 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003468 /*ExplicitArgs*/ nullptr,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003469 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003470 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003471 else
John McCall9aa472c2010-03-19 07:35:19 +00003472 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003473 Initializer, CandidateSet,
Argyrios Kyrtzidisb72db892010-10-05 03:05:30 +00003474 /*SuppressUserConversions=*/true);
Douglas Gregor20093b42009-12-09 23:02:17 +00003475 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003476 }
Douglas Gregor20093b42009-12-09 23:02:17 +00003477 }
John McCall572fc622010-08-17 07:23:57 +00003478 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3479 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003480
Stephen Hines6bcf27b2014-05-29 04:14:42 -07003481 const RecordType *T2RecordType = nullptr;
Douglas Gregor6b6d01f2010-05-07 19:42:26 +00003482 if ((T2RecordType = T2->getAs<RecordType>()) &&
3483 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003484 // The type we're converting from is a class type, enumerate its conversion
3485 // functions.
3486 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3487
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00003488 std::pair<CXXRecordDecl::conversion_iterator,
3489 CXXRecordDecl::conversion_iterator>
3490 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3491 for (CXXRecordDecl::conversion_iterator
3492 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003493 NamedDecl *D = *I;
3494 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3495 if (isa<UsingShadowDecl>(D))
3496 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003497
Douglas Gregor20093b42009-12-09 23:02:17 +00003498 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3499 CXXConversionDecl *Conv;
3500 if (ConvTemplate)
3501 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3502 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003503 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003504
Douglas Gregor20093b42009-12-09 23:02:17 +00003505 // If the conversion function doesn't return a reference type,
3506 // it can't be considered for this conversion unless we're allowed to
3507 // consider rvalues.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003508 // FIXME: Do we need to make sure that we only consider conversion
3509 // candidates with reference-compatible results? That might be needed to
Douglas Gregor20093b42009-12-09 23:02:17 +00003510 // break recursion.
Douglas Gregored878af2012-02-24 23:56:31 +00003511 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
Douglas Gregor20093b42009-12-09 23:02:17 +00003512 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3513 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00003514 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00003515 ActingDC, Initializer,
Stephen Hines651f13c2014-04-23 16:59:28 -07003516 DestType, CandidateSet,
3517 /*AllowObjCConversionOnExplicit=*/
3518 false);
Douglas Gregor20093b42009-12-09 23:02:17 +00003519 else
John McCall9aa472c2010-03-19 07:35:19 +00003520 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Stephen Hines651f13c2014-04-23 16:59:28 -07003521 Initializer, DestType, CandidateSet,
3522 /*AllowObjCConversionOnExplicit=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00003523 }
3524 }
3525 }
John McCall572fc622010-08-17 07:23:57 +00003526 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3527 return OR_No_Viable_Function;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003528
Douglas Gregor20093b42009-12-09 23:02:17 +00003529 SourceLocation DeclLoc = Initializer->getLocStart();
3530
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003531 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor20093b42009-12-09 23:02:17 +00003532 OverloadCandidateSet::iterator Best;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003533 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00003534 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
Douglas Gregor20093b42009-12-09 23:02:17 +00003535 return Result;
Eli Friedman03981012009-12-11 02:42:07 +00003536
Douglas Gregor20093b42009-12-09 23:02:17 +00003537 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00003538 // This is the overload that will be used for this initialization step if we
3539 // use this initialization. Mark it as referenced.
3540 Function->setReferenced();
Chandler Carruth25ca4212011-02-25 19:41:05 +00003541
Eli Friedman03981012009-12-11 02:42:07 +00003542 // Compute the returned type of the conversion.
Douglas Gregor20093b42009-12-09 23:02:17 +00003543 if (isa<CXXConversionDecl>(Function))
Stephen Hines651f13c2014-04-23 16:59:28 -07003544 T2 = Function->getReturnType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003545 else
3546 T2 = cv1T1;
Eli Friedman03981012009-12-11 02:42:07 +00003547
3548 // Add the user-defined conversion step.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003549 bool HadMultipleCandidates = (CandidateSet.size() > 1);
John McCall9aa472c2010-03-19 07:35:19 +00003550 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
Abramo Bagnara22c107b2011-11-19 11:44:21 +00003551 T2.getNonLValueExprType(S.Context),
3552 HadMultipleCandidates);
Eli Friedman03981012009-12-11 02:42:07 +00003553
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003554 // Determine whether we need to perform derived-to-base or
Eli Friedman03981012009-12-11 02:42:07 +00003555 // cv-qualification adjustments.
John McCall5baba9d2010-08-25 10:28:54 +00003556 ExprValueKind VK = VK_RValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003557 if (T2->isLValueReferenceType())
John McCall5baba9d2010-08-25 10:28:54 +00003558 VK = VK_LValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003559 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
John McCall5baba9d2010-08-25 10:28:54 +00003560 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
Sebastian Redl906082e2010-07-20 04:20:21 +00003561
Douglas Gregor20093b42009-12-09 23:02:17 +00003562 bool NewDerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003563 bool NewObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003564 bool NewObjCLifetimeConversion = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00003565 Sema::ReferenceCompareResult NewRefRelationship
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003566 = S.CompareReferenceRelationship(DeclLoc, T1,
Douglas Gregor63982352010-07-13 18:40:04 +00003567 T2.getNonLValueExprType(S.Context),
John McCallf85e1932011-06-15 23:02:42 +00003568 NewDerivedToBase, NewObjCConversion,
3569 NewObjCLifetimeConversion);
Douglas Gregora1a9f032010-03-07 23:17:44 +00003570 if (NewRefRelationship == Sema::Ref_Incompatible) {
3571 // If the type we've converted to is not reference-related to the
3572 // type we're looking for, then there is another conversion step
3573 // we need to perform to produce a temporary of the right type
3574 // that we'll be binding to.
3575 ImplicitConversionSequence ICS;
3576 ICS.setStandard();
3577 ICS.Standard = Best->FinalConversion;
3578 T2 = ICS.Standard.getToType(2);
3579 Sequence.AddConversionSequenceStep(ICS, T2);
3580 } else if (NewDerivedToBase)
Douglas Gregor20093b42009-12-09 23:02:17 +00003581 Sequence.AddDerivedToBaseCastStep(
3582 S.Context.getQualifiedType(T1,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003583 T2.getNonReferenceType().getQualifiers()),
John McCall5baba9d2010-08-25 10:28:54 +00003584 VK);
Douglas Gregor569c3162010-08-07 11:51:51 +00003585 else if (NewObjCConversion)
3586 Sequence.AddObjCObjectConversionStep(
3587 S.Context.getQualifiedType(T1,
3588 T2.getNonReferenceType().getQualifiers()));
3589
Douglas Gregor20093b42009-12-09 23:02:17 +00003590 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
John McCall5baba9d2010-08-25 10:28:54 +00003591 Sequence.AddQualificationConversionStep(cv1T1, VK);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003592
Douglas Gregor20093b42009-12-09 23:02:17 +00003593 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3594 return OR_Success;
3595}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003596
Richard Smith83da2e72011-10-19 16:55:56 +00003597static void CheckCXX98CompatAccessibleCopy(Sema &S,
3598 const InitializedEntity &Entity,
3599 Expr *CurInitExpr);
3600
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003601/// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3602static void TryReferenceInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003603 const InitializedEntity &Entity,
3604 const InitializationKind &Kind,
3605 Expr *Initializer,
3606 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003607 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00003608 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003609 Qualifiers T1Quals;
3610 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
Douglas Gregor20093b42009-12-09 23:02:17 +00003611 QualType cv2T2 = Initializer->getType();
Chandler Carruth5535c382010-01-12 20:32:25 +00003612 Qualifiers T2Quals;
3613 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003614
Douglas Gregor20093b42009-12-09 23:02:17 +00003615 // If the initializer is the address of an overloaded function, try
3616 // to resolve the overloaded function. If all goes well, T2 is the
3617 // type of the resulting function.
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003618 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3619 T1, Sequence))
3620 return;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003621
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003622 // Delegate everything else to a subfunction.
3623 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3624 T1Quals, cv2T2, T2, T2Quals, Sequence);
3625}
3626
Jordan Rose1fd1e282013-04-11 00:58:58 +00003627/// Converts the target of reference initialization so that it has the
3628/// appropriate qualifiers and value kind.
3629///
3630/// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
3631/// \code
3632/// int x;
3633/// const int &r = x;
3634/// \endcode
3635///
3636/// In this case the reference is binding to a bitfield lvalue, which isn't
3637/// valid. Perform a load to create a lifetime-extended temporary instead.
3638/// \code
3639/// const int &r = someStruct.bitfield;
3640/// \endcode
3641static ExprValueKind
3642convertQualifiersAndValueKindIfNecessary(Sema &S,
3643 InitializationSequence &Sequence,
3644 Expr *Initializer,
3645 QualType cv1T1,
3646 Qualifiers T1Quals,
3647 Qualifiers T2Quals,
3648 bool IsLValueRef) {
John McCall993f43f2013-05-06 21:39:12 +00003649 bool IsNonAddressableType = Initializer->refersToBitField() ||
Jordan Rose1fd1e282013-04-11 00:58:58 +00003650 Initializer->refersToVectorElement();
3651
3652 if (IsNonAddressableType) {
3653 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
3654 // lvalue reference to a non-volatile const type, or the reference shall be
3655 // an rvalue reference.
3656 //
3657 // If not, we can't make a temporary and bind to that. Give up and allow the
3658 // error to be diagnosed later.
3659 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
3660 assert(Initializer->isGLValue());
3661 return Initializer->getValueKind();
3662 }
3663
3664 // Force a load so we can materialize a temporary.
3665 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
3666 return VK_RValue;
3667 }
3668
3669 if (T1Quals != T2Quals) {
3670 Sequence.AddQualificationConversionStep(cv1T1,
3671 Initializer->getValueKind());
3672 }
3673
3674 return Initializer->getValueKind();
3675}
3676
3677
Sebastian Redl13dc8f92011-11-27 16:50:07 +00003678/// \brief Reference initialization without resolving overloaded functions.
3679static void TryReferenceInitializationCore(Sema &S,
3680 const InitializedEntity &Entity,
3681 const InitializationKind &Kind,
3682 Expr *Initializer,
3683 QualType cv1T1, QualType T1,
3684 Qualifiers T1Quals,
3685 QualType cv2T2, QualType T2,
3686 Qualifiers T2Quals,
3687 InitializationSequence &Sequence) {
3688 QualType DestType = Entity.getType();
3689 SourceLocation DeclLoc = Initializer->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00003690 // Compute some basic properties of the types and the initializer.
3691 bool isLValueRef = DestType->isLValueReferenceType();
3692 bool isRValueRef = !isLValueRef;
3693 bool DerivedToBase = false;
Douglas Gregor569c3162010-08-07 11:51:51 +00003694 bool ObjCConversion = false;
John McCallf85e1932011-06-15 23:02:42 +00003695 bool ObjCLifetimeConversion = false;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003696 Expr::Classification InitCategory = Initializer->Classify(S.Context);
Douglas Gregor20093b42009-12-09 23:02:17 +00003697 Sema::ReferenceCompareResult RefRelationship
Douglas Gregor569c3162010-08-07 11:51:51 +00003698 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
John McCallf85e1932011-06-15 23:02:42 +00003699 ObjCConversion, ObjCLifetimeConversion);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003700
Douglas Gregor20093b42009-12-09 23:02:17 +00003701 // C++0x [dcl.init.ref]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003702 // A reference to type "cv1 T1" is initialized by an expression of type
Douglas Gregor20093b42009-12-09 23:02:17 +00003703 // "cv2 T2" as follows:
3704 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003705 // - If the reference is an lvalue reference and the initializer
Douglas Gregor20093b42009-12-09 23:02:17 +00003706 // expression
Richard Smith867521c2013-09-21 21:23:47 +00003707 // Note the analogous bullet points for rvalue refs to functions. Because
Sebastian Redl4680bf22010-06-30 18:13:39 +00003708 // there are no function rvalues in C++, rvalue refs to functions are treated
3709 // like lvalue refs.
Douglas Gregor20093b42009-12-09 23:02:17 +00003710 OverloadingResult ConvOvlResult = OR_Success;
Sebastian Redl4680bf22010-06-30 18:13:39 +00003711 bool T1Function = T1->isFunctionType();
3712 if (isLValueRef || T1Function) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003713 if (InitCategory.isLValue() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003714 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003715 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003716 RefRelationship == Sema::Ref_Related))) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003717 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
Douglas Gregor20093b42009-12-09 23:02:17 +00003718 // reference-compatible with "cv2 T2," or
3719 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003720 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
Douglas Gregor20093b42009-12-09 23:02:17 +00003721 // bit-field when we're determining whether the reference initialization
Douglas Gregorde4b1d82010-01-29 19:14:02 +00003722 // can occur. However, we do pay attention to whether it is a bit-field
3723 // to decide whether we're actually binding to a temporary created from
3724 // the bit-field.
Douglas Gregor20093b42009-12-09 23:02:17 +00003725 if (DerivedToBase)
3726 Sequence.AddDerivedToBaseCastStep(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003727 S.Context.getQualifiedType(T1, T2Quals),
John McCall5baba9d2010-08-25 10:28:54 +00003728 VK_LValue);
Douglas Gregor569c3162010-08-07 11:51:51 +00003729 else if (ObjCConversion)
3730 Sequence.AddObjCObjectConversionStep(
3731 S.Context.getQualifiedType(T1, T2Quals));
3732
Jordan Rose1fd1e282013-04-11 00:58:58 +00003733 ExprValueKind ValueKind =
3734 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
3735 cv1T1, T1Quals, T2Quals,
3736 isLValueRef);
3737 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
Douglas Gregor20093b42009-12-09 23:02:17 +00003738 return;
3739 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003740
3741 // - has a class type (i.e., T2 is a class type), where T1 is not
3742 // reference-related to T2, and can be implicitly converted to an
3743 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3744 // with "cv3 T3" (this conversion is selected by enumerating the
Douglas Gregor20093b42009-12-09 23:02:17 +00003745 // applicable conversion functions (13.3.1.6) and choosing the best
3746 // one through overload resolution (13.3)),
Sebastian Redl4680bf22010-06-30 18:13:39 +00003747 // If we have an rvalue ref to function type here, the rhs must be
Richard Smith867521c2013-09-21 21:23:47 +00003748 // an rvalue. DR1287 removed the "implicitly" here.
Sebastian Redl4680bf22010-06-30 18:13:39 +00003749 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3750 (isLValueRef || InitCategory.isRValue())) {
Richard Smith867521c2013-09-21 21:23:47 +00003751 ConvOvlResult = TryRefInitWithConversionFunction(
3752 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00003753 if (ConvOvlResult == OR_Success)
3754 return;
Richard Smith867521c2013-09-21 21:23:47 +00003755 if (ConvOvlResult != OR_No_Viable_Function)
John McCall1d318332010-01-12 00:44:57 +00003756 Sequence.SetOverloadFailure(
Richard Smith867521c2013-09-21 21:23:47 +00003757 InitializationSequence::FK_ReferenceInitOverloadFailed,
3758 ConvOvlResult);
Douglas Gregor20093b42009-12-09 23:02:17 +00003759 }
3760 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003761
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003762 // - Otherwise, the reference shall be an lvalue reference to a
Douglas Gregor20093b42009-12-09 23:02:17 +00003763 // non-volatile const type (i.e., cv1 shall be const), or the reference
Douglas Gregor69d83162011-01-20 16:08:06 +00003764 // shall be an rvalue reference.
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003765 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
Douglas Gregor3afb9772010-11-08 15:20:28 +00003766 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3767 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3768 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
Douglas Gregor20093b42009-12-09 23:02:17 +00003769 Sequence.SetOverloadFailure(
3770 InitializationSequence::FK_ReferenceInitOverloadFailed,
3771 ConvOvlResult);
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003772 else
Sebastian Redl4680bf22010-06-30 18:13:39 +00003773 Sequence.SetFailed(InitCategory.isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00003774 ? (RefRelationship == Sema::Ref_Related
3775 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3776 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3777 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
Sebastian Redl4680bf22010-06-30 18:13:39 +00003778
Douglas Gregor20093b42009-12-09 23:02:17 +00003779 return;
3780 }
Sebastian Redl4680bf22010-06-30 18:13:39 +00003781
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003782 // - If the initializer expression
3783 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3784 // "cv1 T1" is reference-compatible with "cv2 T2"
3785 // Note: functions are handled below.
3786 if (!T1Function &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003787 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003788 (Kind.isCStyleOrFunctionalCast() &&
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003789 RefRelationship == Sema::Ref_Related)) &&
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003790 (InitCategory.isXValue() ||
3791 (InitCategory.isPRValue() && T2->isRecordType()) ||
3792 (InitCategory.isPRValue() && T2->isArrayType()))) {
3793 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3794 if (InitCategory.isPRValue() && T2->isRecordType()) {
Douglas Gregor523d46a2010-04-18 07:40:54 +00003795 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3796 // compiler the freedom to perform a copy here or bind to the
3797 // object, while C++0x requires that we bind directly to the
3798 // object. Hence, we always bind to the object without making an
3799 // extra copy. However, in C++03 requires that we check for the
3800 // presence of a suitable copy constructor:
3801 //
3802 // The constructor that would be used to make the copy shall
3803 // be callable whether or not the copy is actually done.
Richard Smith80ad52f2013-01-02 11:42:31 +00003804 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
Douglas Gregor523d46a2010-04-18 07:40:54 +00003805 Sequence.AddExtraneousCopyToTemporary(cv2T2);
Richard Smith80ad52f2013-01-02 11:42:31 +00003806 else if (S.getLangOpts().CPlusPlus11)
Richard Smith83da2e72011-10-19 16:55:56 +00003807 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
Douglas Gregor20093b42009-12-09 23:02:17 +00003808 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003809
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003810 if (DerivedToBase)
3811 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3812 ValueKind);
3813 else if (ObjCConversion)
3814 Sequence.AddObjCObjectConversionStep(
3815 S.Context.getQualifiedType(T1, T2Quals));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003816
Jordan Rose1fd1e282013-04-11 00:58:58 +00003817 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
3818 Initializer, cv1T1,
3819 T1Quals, T2Quals,
3820 isLValueRef);
3821
3822 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003823 return;
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003824 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003825
3826 // - has a class type (i.e., T2 is a class type), where T1 is not
3827 // reference-related to T2, and can be implicitly converted to an
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003828 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3829 // where "cv1 T1" is reference-compatible with "cv3 T3",
Richard Smith867521c2013-09-21 21:23:47 +00003830 //
3831 // DR1287 removes the "implicitly" here.
Douglas Gregorc5db24d2011-01-20 16:44:54 +00003832 if (T2->isRecordType()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003833 if (RefRelationship == Sema::Ref_Incompatible) {
Richard Smith867521c2013-09-21 21:23:47 +00003834 ConvOvlResult = TryRefInitWithConversionFunction(
3835 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
Douglas Gregor20093b42009-12-09 23:02:17 +00003836 if (ConvOvlResult)
3837 Sequence.SetOverloadFailure(
Richard Smith867521c2013-09-21 21:23:47 +00003838 InitializationSequence::FK_ReferenceInitOverloadFailed,
3839 ConvOvlResult);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003840
Douglas Gregor20093b42009-12-09 23:02:17 +00003841 return;
3842 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003843
Douglas Gregordefa32e2013-03-26 23:59:23 +00003844 if ((RefRelationship == Sema::Ref_Compatible ||
3845 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
3846 isRValueRef && InitCategory.isLValue()) {
3847 Sequence.SetFailed(
3848 InitializationSequence::FK_RValueReferenceBindingToLValue);
3849 return;
3850 }
3851
Douglas Gregor20093b42009-12-09 23:02:17 +00003852 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3853 return;
3854 }
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003855
3856 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
Douglas Gregor20093b42009-12-09 23:02:17 +00003857 // from the initializer expression using the rules for a non-reference
Richard Smith4e47ecb2013-06-13 00:57:57 +00003858 // copy-initialization (8.5). The reference is then bound to the
Douglas Gregor20093b42009-12-09 23:02:17 +00003859 // temporary. [...]
John McCall369371c2010-06-04 02:29:22 +00003860
John McCall369371c2010-06-04 02:29:22 +00003861 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3862
Richard Smith4e47ecb2013-06-13 00:57:57 +00003863 // FIXME: Why do we use an implicit conversion here rather than trying
3864 // copy-initialization?
John McCallf85e1932011-06-15 23:02:42 +00003865 ImplicitConversionSequence ICS
3866 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
Richard Smith4e47ecb2013-06-13 00:57:57 +00003867 /*SuppressUserConversions=*/false,
3868 /*AllowExplicit=*/false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00003869 /*FIXME:InOverloadResolution=*/false,
John McCallf85e1932011-06-15 23:02:42 +00003870 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3871 /*AllowObjCWritebackConversion=*/false);
3872
3873 if (ICS.isBad()) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003874 // FIXME: Use the conversion function set stored in ICS to turn
3875 // this into an overloading ambiguity diagnostic. However, we need
3876 // to keep that set as an OverloadCandidateSet rather than as some
3877 // other kind of set.
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003878 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3879 Sequence.SetOverloadFailure(
3880 InitializationSequence::FK_ReferenceInitOverloadFailed,
3881 ConvOvlResult);
Douglas Gregor3afb9772010-11-08 15:20:28 +00003882 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3883 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00003884 else
3885 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
Douglas Gregor20093b42009-12-09 23:02:17 +00003886 return;
John McCallf85e1932011-06-15 23:02:42 +00003887 } else {
3888 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003889 }
3890
3891 // [...] If T1 is reference-related to T2, cv1 must be the
3892 // same cv-qualification as, or greater cv-qualification
3893 // than, cv2; otherwise, the program is ill-formed.
Chandler Carruth5535c382010-01-12 20:32:25 +00003894 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3895 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003896 if (RefRelationship == Sema::Ref_Related &&
Chandler Carruth5535c382010-01-12 20:32:25 +00003897 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
Douglas Gregor20093b42009-12-09 23:02:17 +00003898 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3899 return;
3900 }
3901
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003902 // [...] If T1 is reference-related to T2 and the reference is an rvalue
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003903 // reference, the initializer expression shall not be an lvalue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003904 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
Douglas Gregorb2855ad2011-01-21 00:52:42 +00003905 InitCategory.isLValue()) {
3906 Sequence.SetFailed(
3907 InitializationSequence::FK_RValueReferenceBindingToLValue);
3908 return;
3909 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003910
Douglas Gregor20093b42009-12-09 23:02:17 +00003911 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3912 return;
3913}
3914
3915/// \brief Attempt character array initialization from a string literal
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003916/// (C++ [dcl.init.string], C99 6.7.8).
3917static void TryStringLiteralInitialization(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00003918 const InitializedEntity &Entity,
3919 const InitializationKind &Kind,
3920 Expr *Initializer,
3921 InitializationSequence &Sequence) {
Douglas Gregord6542d82009-12-22 15:35:07 +00003922 Sequence.AddStringInitStep(Entity.getType());
Douglas Gregor20093b42009-12-09 23:02:17 +00003923}
3924
Douglas Gregor71d17402009-12-15 00:01:57 +00003925/// \brief Attempt value initialization (C++ [dcl.init]p7).
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003926static void TryValueInitialization(Sema &S,
Douglas Gregor71d17402009-12-15 00:01:57 +00003927 const InitializedEntity &Entity,
3928 const InitializationKind &Kind,
Richard Smithf4bb8d02012-07-05 08:39:21 +00003929 InitializationSequence &Sequence,
3930 InitListExpr *InitList) {
3931 assert((!InitList || InitList->getNumInits() == 0) &&
3932 "Shouldn't use value-init for non-empty init lists");
3933
Richard Smith1d0c9a82012-02-14 21:14:13 +00003934 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
Douglas Gregor71d17402009-12-15 00:01:57 +00003935 //
3936 // To value-initialize an object of type T means:
Douglas Gregord6542d82009-12-22 15:35:07 +00003937 QualType T = Entity.getType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003938
Douglas Gregor71d17402009-12-15 00:01:57 +00003939 // -- if T is an array type, then each element is value-initialized;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003940 T = S.Context.getBaseElementType(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003941
Douglas Gregor71d17402009-12-15 00:01:57 +00003942 if (const RecordType *RT = T->getAs<RecordType>()) {
3943 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003944 bool NeedZeroInitialization = true;
Richard Smith80ad52f2013-01-02 11:42:31 +00003945 if (!S.getLangOpts().CPlusPlus11) {
Richard Smithf4bb8d02012-07-05 08:39:21 +00003946 // C++98:
3947 // -- if T is a class type (clause 9) with a user-declared constructor
3948 // (12.1), then the default constructor for T is called (and the
3949 // initialization is ill-formed if T has no accessible default
3950 // constructor);
Richard Smith1d0c9a82012-02-14 21:14:13 +00003951 if (ClassDecl->hasUserDeclaredConstructor())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003952 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003953 } else {
3954 // C++11:
3955 // -- if T is a class type (clause 9) with either no default constructor
3956 // (12.1 [class.ctor]) or a default constructor that is user-provided
3957 // or deleted, then the object is default-initialized;
3958 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
3959 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
Richard Smithf4bb8d02012-07-05 08:39:21 +00003960 NeedZeroInitialization = false;
Richard Smith1d0c9a82012-02-14 21:14:13 +00003961 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003962
Richard Smith1d0c9a82012-02-14 21:14:13 +00003963 // -- if T is a (possibly cv-qualified) non-union class type without a
3964 // user-provided or deleted default constructor, then the object is
3965 // zero-initialized and, if T has a non-trivial default constructor,
3966 // default-initialized;
Richard Smith6678a052012-10-18 00:44:17 +00003967 // The 'non-union' here was removed by DR1502. The 'non-trivial default
3968 // constructor' part was removed by DR1507.
Richard Smithf4bb8d02012-07-05 08:39:21 +00003969 if (NeedZeroInitialization)
3970 Sequence.AddZeroInitializationStep(Entity.getType());
3971
Richard Smithd5bc8672012-12-08 02:01:17 +00003972 // C++03:
3973 // -- if T is a non-union class type without a user-declared constructor,
3974 // then every non-static data member and base class component of T is
3975 // value-initialized;
3976 // [...] A program that calls for [...] value-initialization of an
3977 // entity of reference type is ill-formed.
3978 //
3979 // C++11 doesn't need this handling, because value-initialization does not
3980 // occur recursively there, and the implicit default constructor is
3981 // defined as deleted in the problematic cases.
Richard Smith80ad52f2013-01-02 11:42:31 +00003982 if (!S.getLangOpts().CPlusPlus11 &&
Richard Smithd5bc8672012-12-08 02:01:17 +00003983 ClassDecl->hasUninitializedReferenceMember()) {
3984 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
3985 return;
3986 }
3987
Richard Smithf4bb8d02012-07-05 08:39:21 +00003988 // If this is list-value-initialization, pass the empty init list on when
3989 // building the constructor call. This affects the semantics of a few
3990 // things (such as whether an explicit default constructor can be called).
3991 Expr *InitListAsExpr = InitList;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003992 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
Richard Smithf4bb8d02012-07-05 08:39:21 +00003993 bool InitListSyntax = InitList;
3994
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00003995 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
3996 InitListSyntax);
Douglas Gregor71d17402009-12-15 00:01:57 +00003997 }
3998 }
3999
Douglas Gregord6542d82009-12-22 15:35:07 +00004000 Sequence.AddZeroInitializationStep(Entity.getType());
Douglas Gregor71d17402009-12-15 00:01:57 +00004001}
4002
Douglas Gregor99a2e602009-12-16 01:38:02 +00004003/// \brief Attempt default initialization (C++ [dcl.init]p6).
4004static void TryDefaultInitialization(Sema &S,
4005 const InitializedEntity &Entity,
4006 const InitializationKind &Kind,
4007 InitializationSequence &Sequence) {
4008 assert(Kind.getKind() == InitializationKind::IK_Default);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004009
Douglas Gregor99a2e602009-12-16 01:38:02 +00004010 // C++ [dcl.init]p6:
4011 // To default-initialize an object of type T means:
4012 // - if T is an array type, each element is default-initialized;
John McCallf85e1932011-06-15 23:02:42 +00004013 QualType DestType = S.Context.getBaseElementType(Entity.getType());
4014
Douglas Gregor99a2e602009-12-16 01:38:02 +00004015 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4016 // constructor for T is called (and the initialization is ill-formed if
4017 // T has no accessible default constructor);
David Blaikie4e4d0842012-03-11 07:00:24 +00004018 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
Dmitri Gribenko62ed8892013-05-05 20:40:26 +00004019 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
Chandler Carruth4e6fbce2010-08-23 07:55:51 +00004020 return;
Douglas Gregor99a2e602009-12-16 01:38:02 +00004021 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004022
Douglas Gregor99a2e602009-12-16 01:38:02 +00004023 // - otherwise, no initialization is performed.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004024
Douglas Gregor99a2e602009-12-16 01:38:02 +00004025 // If a program calls for the default initialization of an object of
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004026 // a const-qualified type T, T shall be a class type with a user-provided
Douglas Gregor99a2e602009-12-16 01:38:02 +00004027 // default constructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00004028 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
Douglas Gregor99a2e602009-12-16 01:38:02 +00004029 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
John McCallf85e1932011-06-15 23:02:42 +00004030 return;
4031 }
4032
4033 // If the destination type has a lifetime property, zero-initialize it.
4034 if (DestType.getQualifiers().hasObjCLifetime()) {
4035 Sequence.AddZeroInitializationStep(Entity.getType());
4036 return;
4037 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00004038}
4039
Douglas Gregor20093b42009-12-09 23:02:17 +00004040/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4041/// which enumerates all conversion functions and performs overload resolution
4042/// to select the best.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004043static void TryUserDefinedConversion(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00004044 const InitializedEntity &Entity,
4045 const InitializationKind &Kind,
4046 Expr *Initializer,
Richard Smith13b228d2013-09-21 21:19:19 +00004047 InitializationSequence &Sequence,
4048 bool TopLevelOfInitList) {
Douglas Gregord6542d82009-12-22 15:35:07 +00004049 QualType DestType = Entity.getType();
Douglas Gregor4a520a22009-12-14 17:27:33 +00004050 assert(!DestType->isReferenceType() && "References are handled elsewhere");
4051 QualType SourceType = Initializer->getType();
4052 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4053 "Must have a class type to perform a user-defined conversion");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004054
Douglas Gregor4a520a22009-12-14 17:27:33 +00004055 // Build the candidate set directly in the initialization sequence
4056 // structure, so that it will persist if we fail.
4057 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4058 CandidateSet.clear();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004059
Douglas Gregor4a520a22009-12-14 17:27:33 +00004060 // Determine whether we are allowed to call explicit constructors or
4061 // explicit conversion operators.
Sebastian Redl168319c2012-02-12 16:37:24 +00004062 bool AllowExplicit = Kind.AllowExplicit();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004063
Douglas Gregor4a520a22009-12-14 17:27:33 +00004064 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4065 // The type we're converting to is a class type. Enumerate its constructors
4066 // to see if there is a suitable conversion.
4067 CXXRecordDecl *DestRecordDecl
4068 = cast<CXXRecordDecl>(DestRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004069
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004070 // Try to complete the type we're converting to.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004071 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004072 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004073 // The container holding the constructors can under certain conditions
4074 // be changed while iterating. To be safe we copy the lookup results
4075 // to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004076 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00004077 for (SmallVectorImpl<NamedDecl *>::iterator
David Blaikie3d5cf5e2012-10-18 16:57:32 +00004078 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004079 Con != ConEnd; ++Con) {
4080 NamedDecl *D = *Con;
4081 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004082
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004083 // Find the constructor (which may be a template).
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004084 CXXConstructorDecl *Constructor = nullptr;
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004085 FunctionTemplateDecl *ConstructorTmpl
4086 = dyn_cast<FunctionTemplateDecl>(D);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004087 if (ConstructorTmpl)
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004088 Constructor = cast<CXXConstructorDecl>(
4089 ConstructorTmpl->getTemplatedDecl());
Douglas Gregor4712c022010-07-01 03:43:00 +00004090 else
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004091 Constructor = cast<CXXConstructorDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004092
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004093 if (!Constructor->isInvalidDecl() &&
4094 Constructor->isConvertingConstructor(AllowExplicit)) {
4095 if (ConstructorTmpl)
4096 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004097 /*ExplicitArgs*/ nullptr,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004098 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004099 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004100 else
4101 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004102 Initializer, CandidateSet,
Douglas Gregor4712c022010-07-01 03:43:00 +00004103 /*SuppressUserConversions=*/true);
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004104 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004105 }
Douglas Gregor087fb7d2010-04-26 14:36:57 +00004106 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004107 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004108
4109 SourceLocation DeclLoc = Initializer->getLocStart();
4110
Douglas Gregor4a520a22009-12-14 17:27:33 +00004111 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4112 // The type we're converting from is a class type, enumerate its conversion
4113 // functions.
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004114
Eli Friedman33c2da92009-12-20 22:12:03 +00004115 // We can only enumerate the conversion functions for a complete type; if
4116 // the type isn't complete, simply skip this step.
4117 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4118 CXXRecordDecl *SourceRecordDecl
4119 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004120
Argyrios Kyrtzidis9d295432012-11-28 03:56:09 +00004121 std::pair<CXXRecordDecl::conversion_iterator,
4122 CXXRecordDecl::conversion_iterator>
4123 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
4124 for (CXXRecordDecl::conversion_iterator
4125 I = Conversions.first, E = Conversions.second; I != E; ++I) {
Eli Friedman33c2da92009-12-20 22:12:03 +00004126 NamedDecl *D = *I;
4127 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4128 if (isa<UsingShadowDecl>(D))
4129 D = cast<UsingShadowDecl>(D)->getTargetDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004130
Eli Friedman33c2da92009-12-20 22:12:03 +00004131 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4132 CXXConversionDecl *Conv;
Douglas Gregor4a520a22009-12-14 17:27:33 +00004133 if (ConvTemplate)
Eli Friedman33c2da92009-12-20 22:12:03 +00004134 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
Douglas Gregor4a520a22009-12-14 17:27:33 +00004135 else
John McCall32daa422010-03-31 01:36:47 +00004136 Conv = cast<CXXConversionDecl>(D);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004137
Eli Friedman33c2da92009-12-20 22:12:03 +00004138 if (AllowExplicit || !Conv->isExplicit()) {
4139 if (ConvTemplate)
John McCall9aa472c2010-03-19 07:35:19 +00004140 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
John McCall86820f52010-01-26 01:37:31 +00004141 ActingDC, Initializer, DestType,
Stephen Hines651f13c2014-04-23 16:59:28 -07004142 CandidateSet, AllowExplicit);
Eli Friedman33c2da92009-12-20 22:12:03 +00004143 else
John McCall9aa472c2010-03-19 07:35:19 +00004144 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
Stephen Hines651f13c2014-04-23 16:59:28 -07004145 Initializer, DestType, CandidateSet,
4146 AllowExplicit);
Eli Friedman33c2da92009-12-20 22:12:03 +00004147 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004148 }
4149 }
4150 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004151
4152 // Perform overload resolution. If it fails, return the failed result.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004153 OverloadCandidateSet::iterator Best;
John McCall1d318332010-01-12 00:44:57 +00004154 if (OverloadingResult Result
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004155 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
Douglas Gregor4a520a22009-12-14 17:27:33 +00004156 Sequence.SetOverloadFailure(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004157 InitializationSequence::FK_UserConversionOverloadFailed,
Douglas Gregor4a520a22009-12-14 17:27:33 +00004158 Result);
4159 return;
4160 }
John McCall1d318332010-01-12 00:44:57 +00004161
Douglas Gregor4a520a22009-12-14 17:27:33 +00004162 FunctionDecl *Function = Best->Function;
Nick Lewycky3c86a5c2013-02-12 08:08:54 +00004163 Function->setReferenced();
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004164 bool HadMultipleCandidates = (CandidateSet.size() > 1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004165
Douglas Gregor4a520a22009-12-14 17:27:33 +00004166 if (isa<CXXConstructorDecl>(Function)) {
4167 // Add the user-defined conversion step. Any cv-qualification conversion is
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004168 // subsumed by the initialization. Per DR5, the created temporary is of the
4169 // cv-unqualified type of the destination.
4170 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4171 DestType.getUnqualifiedType(),
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004172 HadMultipleCandidates);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004173 return;
4174 }
4175
4176 // Add the user-defined conversion step that calls the conversion function.
Douglas Gregor5291c3c2010-07-13 08:18:22 +00004177 QualType ConvType = Function->getCallResultType();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004178 if (ConvType->getAs<RecordType>()) {
Richard Smithf2e4dfc2012-02-11 19:22:50 +00004179 // If we're converting to a class type, there may be an copy of
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004180 // the resulting temporary object (possible to create an object of
4181 // a base class type). That copy is not a separate conversion, so
4182 // we just make a note of the actual destination type (possibly a
4183 // base class of the type returned by the conversion function) and
4184 // let the user-defined conversion step handle the conversion.
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004185 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4186 HadMultipleCandidates);
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004187 return;
4188 }
Douglas Gregor4a520a22009-12-14 17:27:33 +00004189
Abramo Bagnara22c107b2011-11-19 11:44:21 +00004190 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4191 HadMultipleCandidates);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004192
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004193 // If the conversion following the call to the conversion function
4194 // is interesting, add it as a separate step.
Douglas Gregor4a520a22009-12-14 17:27:33 +00004195 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4196 Best->FinalConversion.Third) {
4197 ImplicitConversionSequence ICS;
John McCall1d318332010-01-12 00:44:57 +00004198 ICS.setStandard();
Douglas Gregor4a520a22009-12-14 17:27:33 +00004199 ICS.Standard = Best->FinalConversion;
Richard Smith13b228d2013-09-21 21:19:19 +00004200 Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
Douglas Gregor4a520a22009-12-14 17:27:33 +00004201 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004202}
4203
Richard Smith87c29322013-06-20 02:18:31 +00004204/// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4205/// a function with a pointer return type contains a 'return false;' statement.
4206/// In C++11, 'false' is not a null pointer, so this breaks the build of any
4207/// code using that header.
4208///
4209/// Work around this by treating 'return false;' as zero-initializing the result
4210/// if it's used in a pointer-returning function in a system header.
4211static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4212 const InitializedEntity &Entity,
4213 const Expr *Init) {
4214 return S.getLangOpts().CPlusPlus11 &&
4215 Entity.getKind() == InitializedEntity::EK_Result &&
4216 Entity.getType()->isPointerType() &&
4217 isa<CXXBoolLiteralExpr>(Init) &&
4218 !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4219 S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4220}
4221
John McCallf85e1932011-06-15 23:02:42 +00004222/// The non-zero enum values here are indexes into diagnostic alternatives.
4223enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4224
4225/// Determines whether this expression is an acceptable ICR source.
John McCallc03fa492011-06-27 23:59:58 +00004226static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004227 bool isAddressOf, bool &isWeakAccess) {
John McCallf85e1932011-06-15 23:02:42 +00004228 // Skip parens.
4229 e = e->IgnoreParens();
4230
4231 // Skip address-of nodes.
4232 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4233 if (op->getOpcode() == UO_AddrOf)
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004234 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4235 isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004236
4237 // Skip certain casts.
John McCallc03fa492011-06-27 23:59:58 +00004238 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4239 switch (ce->getCastKind()) {
John McCallf85e1932011-06-15 23:02:42 +00004240 case CK_Dependent:
4241 case CK_BitCast:
4242 case CK_LValueBitCast:
John McCallf85e1932011-06-15 23:02:42 +00004243 case CK_NoOp:
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004244 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004245
4246 case CK_ArrayToPointerDecay:
4247 return IIK_nonscalar;
4248
4249 case CK_NullToPointer:
4250 return IIK_okay;
4251
4252 default:
4253 break;
4254 }
4255
4256 // If we have a declaration reference, it had better be a local variable.
John McCallf4b88a42012-03-10 09:33:50 +00004257 } else if (isa<DeclRefExpr>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004258 // set isWeakAccess to true, to mean that there will be an implicit
4259 // load which requires a cleanup.
4260 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4261 isWeakAccess = true;
4262
John McCallc03fa492011-06-27 23:59:58 +00004263 if (!isAddressOf) return IIK_nonlocal;
4264
John McCallf4b88a42012-03-10 09:33:50 +00004265 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4266 if (!var) return IIK_nonlocal;
John McCallc03fa492011-06-27 23:59:58 +00004267
4268 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
John McCallf85e1932011-06-15 23:02:42 +00004269
4270 // If we have a conditional operator, check both sides.
4271 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004272 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4273 isWeakAccess))
John McCallf85e1932011-06-15 23:02:42 +00004274 return iik;
4275
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004276 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
John McCallf85e1932011-06-15 23:02:42 +00004277
4278 // These are never scalar.
4279 } else if (isa<ArraySubscriptExpr>(e)) {
4280 return IIK_nonscalar;
4281
4282 // Otherwise, it needs to be a null pointer constant.
4283 } else {
4284 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4285 ? IIK_okay : IIK_nonlocal);
4286 }
4287
4288 return IIK_nonlocal;
4289}
4290
4291/// Check whether the given expression is a valid operand for an
4292/// indirect copy/restore.
4293static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4294 assert(src->isRValue());
Fariborz Jahanian82c458e2012-11-27 23:02:53 +00004295 bool isWeakAccess = false;
4296 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4297 // If isWeakAccess to true, there will be an implicit
4298 // load which requires a cleanup.
4299 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4300 S.ExprNeedsCleanups = true;
4301
John McCallf85e1932011-06-15 23:02:42 +00004302 if (iik == IIK_okay) return;
4303
4304 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4305 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4306 << src->getSourceRange();
4307}
4308
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004309/// \brief Determine whether we have compatible array types for the
4310/// purposes of GNU by-copy array initialization.
4311static bool hasCompatibleArrayTypes(ASTContext &Context,
4312 const ArrayType *Dest,
4313 const ArrayType *Source) {
4314 // If the source and destination array types are equivalent, we're
4315 // done.
4316 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4317 return true;
4318
4319 // Make sure that the element types are the same.
4320 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4321 return false;
4322
4323 // The only mismatch we allow is when the destination is an
4324 // incomplete array type and the source is a constant array type.
4325 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4326}
4327
John McCallf85e1932011-06-15 23:02:42 +00004328static bool tryObjCWritebackConversion(Sema &S,
4329 InitializationSequence &Sequence,
4330 const InitializedEntity &Entity,
4331 Expr *Initializer) {
4332 bool ArrayDecay = false;
4333 QualType ArgType = Initializer->getType();
4334 QualType ArgPointee;
4335 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4336 ArrayDecay = true;
4337 ArgPointee = ArgArrayType->getElementType();
4338 ArgType = S.Context.getPointerType(ArgPointee);
4339 }
4340
4341 // Handle write-back conversion.
4342 QualType ConvertedArgType;
4343 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4344 ConvertedArgType))
4345 return false;
4346
4347 // We should copy unless we're passing to an argument explicitly
4348 // marked 'out'.
4349 bool ShouldCopy = true;
4350 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4351 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4352
4353 // Do we need an lvalue conversion?
4354 if (ArrayDecay || Initializer->isGLValue()) {
4355 ImplicitConversionSequence ICS;
4356 ICS.setStandard();
4357 ICS.Standard.setAsIdentityConversion();
4358
4359 QualType ResultType;
4360 if (ArrayDecay) {
4361 ICS.Standard.First = ICK_Array_To_Pointer;
4362 ResultType = S.Context.getPointerType(ArgPointee);
4363 } else {
4364 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4365 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4366 }
4367
4368 Sequence.AddConversionSequenceStep(ICS, ResultType);
4369 }
4370
4371 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4372 return true;
4373}
4374
Guy Benyei21f18c42013-02-07 10:55:47 +00004375static bool TryOCLSamplerInitialization(Sema &S,
4376 InitializationSequence &Sequence,
4377 QualType DestType,
4378 Expr *Initializer) {
4379 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4380 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4381 return false;
4382
4383 Sequence.AddOCLSamplerInitStep(DestType);
4384 return true;
4385}
4386
Guy Benyeie6b9d802013-01-20 12:31:11 +00004387//
4388// OpenCL 1.2 spec, s6.12.10
4389//
4390// The event argument can also be used to associate the
4391// async_work_group_copy with a previous async copy allowing
4392// an event to be shared by multiple async copies; otherwise
4393// event should be zero.
4394//
4395static bool TryOCLZeroEventInitialization(Sema &S,
4396 InitializationSequence &Sequence,
4397 QualType DestType,
4398 Expr *Initializer) {
4399 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4400 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4401 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4402 return false;
4403
4404 Sequence.AddOCLZeroEventStep(DestType);
4405 return true;
4406}
4407
Douglas Gregor20093b42009-12-09 23:02:17 +00004408InitializationSequence::InitializationSequence(Sema &S,
4409 const InitializedEntity &Entity,
4410 const InitializationKind &Kind,
Richard Smith13b228d2013-09-21 21:19:19 +00004411 MultiExprArg Args,
4412 bool TopLevelOfInitList)
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004413 : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
Richard Smithb390e492013-09-21 21:55:46 +00004414 InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4415}
4416
4417void InitializationSequence::InitializeFrom(Sema &S,
4418 const InitializedEntity &Entity,
4419 const InitializationKind &Kind,
4420 MultiExprArg Args,
4421 bool TopLevelOfInitList) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004422 ASTContext &Context = S.Context;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004423
John McCall76da55d2013-04-16 07:28:30 +00004424 // Eliminate non-overload placeholder types in the arguments. We
4425 // need to do this before checking whether types are dependent
4426 // because lowering a pseudo-object expression might well give us
4427 // something of dependent type.
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004428 for (unsigned I = 0, E = Args.size(); I != E; ++I)
John McCall76da55d2013-04-16 07:28:30 +00004429 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4430 // FIXME: should we be doing this here?
4431 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4432 if (result.isInvalid()) {
4433 SetFailed(FK_PlaceholderType);
4434 return;
4435 }
4436 Args[I] = result.take();
4437 }
4438
Douglas Gregor20093b42009-12-09 23:02:17 +00004439 // C++0x [dcl.init]p16:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004440 // The semantics of initializers are as follows. The destination type is
4441 // the type of the object or reference being initialized and the source
Douglas Gregor20093b42009-12-09 23:02:17 +00004442 // type is the type of the initializer expression. The source type is not
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004443 // defined when the initializer is a braced-init-list or when it is a
Douglas Gregor20093b42009-12-09 23:02:17 +00004444 // parenthesized list of expressions.
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004445 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00004446
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004447 if (DestType->isDependentType() ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004448 Expr::hasAnyTypeDependentArguments(Args)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004449 SequenceKind = DependentSequence;
4450 return;
4451 }
4452
Sebastian Redl7491c492011-06-05 13:59:11 +00004453 // Almost everything is a normal sequence.
4454 setSequenceKind(NormalSequence);
4455
Douglas Gregor20093b42009-12-09 23:02:17 +00004456 QualType SourceType;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004457 Expr *Initializer = nullptr;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004458 if (Args.size() == 1) {
Douglas Gregor20093b42009-12-09 23:02:17 +00004459 Initializer = Args[0];
Stephen Hines651f13c2014-04-23 16:59:28 -07004460 if (S.getLangOpts().ObjC1) {
4461 if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
4462 DestType, Initializer->getType(),
4463 Initializer) ||
4464 S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
4465 Args[0] = Initializer;
4466
4467 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004468 if (!isa<InitListExpr>(Initializer))
4469 SourceType = Initializer->getType();
4470 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004471
Sebastian Redl3a45c0e2012-02-12 16:37:36 +00004472 // - If the initializer is a (non-parenthesized) braced-init-list, the
4473 // object is list-initialized (8.5.4).
4474 if (Kind.getKind() != InitializationKind::IK_Direct) {
4475 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4476 TryListInitialization(S, Entity, Kind, InitList, *this);
4477 return;
4478 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004479 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004480
Douglas Gregor20093b42009-12-09 23:02:17 +00004481 // - If the destination type is a reference type, see 8.5.3.
4482 if (DestType->isReferenceType()) {
4483 // C++0x [dcl.init.ref]p1:
4484 // A variable declared to be a T& or T&&, that is, "reference to type T"
4485 // (8.3.2), shall be initialized by an object, or function, of type T or
4486 // by an object that can be converted into a T.
4487 // (Therefore, multiple arguments are not permitted.)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004488 if (Args.size() != 1)
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004489 SetFailed(FK_TooManyInitsForReference);
Douglas Gregor20093b42009-12-09 23:02:17 +00004490 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004491 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004492 return;
4493 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004494
Douglas Gregor20093b42009-12-09 23:02:17 +00004495 // - If the initializer is (), the object is value-initialized.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004496 if (Kind.getKind() == InitializationKind::IK_Value ||
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004497 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004498 TryValueInitialization(S, Entity, Kind, *this);
Douglas Gregor20093b42009-12-09 23:02:17 +00004499 return;
4500 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004501
Douglas Gregor99a2e602009-12-16 01:38:02 +00004502 // Handle default initialization.
Nick Lewycky7663f392010-11-20 01:29:55 +00004503 if (Kind.getKind() == InitializationKind::IK_Default) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004504 TryDefaultInitialization(S, Entity, Kind, *this);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004505 return;
4506 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004507
John McCallce6c9b72011-02-21 07:22:22 +00004508 // - If the destination type is an array of characters, an array of
4509 // char16_t, an array of char32_t, or an array of wchar_t, and the
4510 // initializer is a string literal, see 8.5.2.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004511 // - Otherwise, if the destination type is an array, the program is
Douglas Gregor20093b42009-12-09 23:02:17 +00004512 // ill-formed.
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004513 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
John McCall73076432012-01-05 00:13:19 +00004514 if (Initializer && isa<VariableArrayType>(DestAT)) {
4515 SetFailed(FK_VariableLengthArrayHasInitializer);
4516 return;
4517 }
4518
Hans Wennborg0ff50742013-05-15 11:03:04 +00004519 if (Initializer) {
4520 switch (IsStringInit(Initializer, DestAT, Context)) {
4521 case SIF_None:
4522 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4523 return;
4524 case SIF_NarrowStringIntoWideChar:
4525 SetFailed(FK_NarrowStringIntoWideCharArray);
4526 return;
4527 case SIF_WideStringIntoChar:
4528 SetFailed(FK_WideStringIntoCharArray);
4529 return;
4530 case SIF_IncompatWideStringIntoWideChar:
4531 SetFailed(FK_IncompatWideStringIntoWideChar);
4532 return;
4533 case SIF_Other:
4534 break;
4535 }
John McCallce6c9b72011-02-21 07:22:22 +00004536 }
4537
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004538 // Note: as an GNU C extension, we allow initialization of an
4539 // array from a compound literal that creates an array of the same
4540 // type, so long as the initializer has no side effects.
David Blaikie4e4d0842012-03-11 07:00:24 +00004541 if (!S.getLangOpts().CPlusPlus && Initializer &&
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004542 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4543 Initializer->getType()->isArrayType()) {
4544 const ArrayType *SourceAT
4545 = Context.getAsArrayType(Initializer->getType());
4546 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004547 SetFailed(FK_ArrayTypeMismatch);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004548 else if (Initializer->HasSideEffects(S.Context))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004549 SetFailed(FK_NonConstantArrayInit);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004550 else {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004551 AddArrayInitStep(DestType);
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00004552 }
Richard Smith0f163e92012-02-15 22:38:09 +00004553 }
Richard Smithf4bb8d02012-07-05 08:39:21 +00004554 // Note: as a GNU C++ extension, we allow list-initialization of a
4555 // class member of array type from a parenthesized initializer list.
David Blaikie4e4d0842012-03-11 07:00:24 +00004556 else if (S.getLangOpts().CPlusPlus &&
Richard Smith0f163e92012-02-15 22:38:09 +00004557 Entity.getKind() == InitializedEntity::EK_Member &&
4558 Initializer && isa<InitListExpr>(Initializer)) {
4559 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4560 *this);
4561 AddParenthesizedArrayInitStep(DestType);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004562 } else if (DestAT->getElementType()->isCharType())
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004563 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
Hans Wennborg0ff50742013-05-15 11:03:04 +00004564 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4565 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
Douglas Gregor20093b42009-12-09 23:02:17 +00004566 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004567 SetFailed(FK_ArrayNeedsInitList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004568
Douglas Gregor20093b42009-12-09 23:02:17 +00004569 return;
4570 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004571
John McCallf85e1932011-06-15 23:02:42 +00004572 // Determine whether we should consider writeback conversions for
4573 // Objective-C ARC.
David Blaikie4e4d0842012-03-11 07:00:24 +00004574 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004575 Entity.isParameterKind();
John McCallf85e1932011-06-15 23:02:42 +00004576
4577 // We're at the end of the line for C: it's either a write-back conversion
4578 // or it's a C assignment. There's no need to check anything else.
David Blaikie4e4d0842012-03-11 07:00:24 +00004579 if (!S.getLangOpts().CPlusPlus) {
John McCallf85e1932011-06-15 23:02:42 +00004580 // If allowed, check whether this is an Objective-C writeback conversion.
4581 if (allowObjCWritebackConversion &&
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004582 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
John McCallf85e1932011-06-15 23:02:42 +00004583 return;
4584 }
Guy Benyei21f18c42013-02-07 10:55:47 +00004585
4586 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4587 return;
Guy Benyeie6b9d802013-01-20 12:31:11 +00004588
4589 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4590 return;
4591
John McCallf85e1932011-06-15 23:02:42 +00004592 // Handle initialization in C
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004593 AddCAssignmentStep(DestType);
4594 MaybeProduceObjCObject(S, *this, Entity);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00004595 return;
4596 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004597
David Blaikie4e4d0842012-03-11 07:00:24 +00004598 assert(S.getLangOpts().CPlusPlus);
John McCallf85e1932011-06-15 23:02:42 +00004599
Douglas Gregor20093b42009-12-09 23:02:17 +00004600 // - If the destination type is a (possibly cv-qualified) class type:
4601 if (DestType->isRecordType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004602 // - If the initialization is direct-initialization, or if it is
4603 // copy-initialization where the cv-unqualified version of the
4604 // source type is the same class as, or a derived class of, the
Douglas Gregor20093b42009-12-09 23:02:17 +00004605 // class of the destination, constructors are considered. [...]
4606 if (Kind.getKind() == InitializationKind::IK_Direct ||
4607 (Kind.getKind() == InitializationKind::IK_Copy &&
4608 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4609 S.IsDerivedFrom(SourceType, DestType))))
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004610 TryConstructorInitialization(S, Entity, Kind, Args,
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004611 Entity.getType(), *this);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004612 // - Otherwise (i.e., for the remaining copy-initialization cases),
Douglas Gregor20093b42009-12-09 23:02:17 +00004613 // user-defined conversion sequences that can convert from the source
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004614 // type to the destination type or (when a conversion function is
Douglas Gregor20093b42009-12-09 23:02:17 +00004615 // used) to a derived class thereof are enumerated as described in
4616 // 13.3.1.4, and the best one is chosen through overload resolution
4617 // (13.3).
4618 else
Richard Smith13b228d2013-09-21 21:19:19 +00004619 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4620 TopLevelOfInitList);
Douglas Gregor20093b42009-12-09 23:02:17 +00004621 return;
4622 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004623
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004624 if (Args.size() > 1) {
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004625 SetFailed(FK_TooManyInitsForScalar);
Douglas Gregor99a2e602009-12-16 01:38:02 +00004626 return;
4627 }
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00004628 assert(Args.size() == 1 && "Zero-argument case handled above");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004629
4630 // - Otherwise, if the source type is a (possibly cv-qualified) class
Douglas Gregor20093b42009-12-09 23:02:17 +00004631 // type, conversion functions are considered.
Douglas Gregor99a2e602009-12-16 01:38:02 +00004632 if (!SourceType.isNull() && SourceType->isRecordType()) {
Richard Smith13b228d2013-09-21 21:19:19 +00004633 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4634 TopLevelOfInitList);
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004635 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00004636 return;
4637 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004638
Douglas Gregor20093b42009-12-09 23:02:17 +00004639 // - Otherwise, the initial value of the object being initialized is the
Douglas Gregor4a520a22009-12-14 17:27:33 +00004640 // (possibly converted) value of the initializer expression. Standard
Douglas Gregor20093b42009-12-09 23:02:17 +00004641 // conversions (Clause 4) will be used, if necessary, to convert the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004642 // initializer expression to the cv-unqualified version of the
Douglas Gregor20093b42009-12-09 23:02:17 +00004643 // destination type; no user-defined conversions are considered.
John McCallf85e1932011-06-15 23:02:42 +00004644
4645 ImplicitConversionSequence ICS
4646 = S.TryImplicitConversion(Initializer, Entity.getType(),
4647 /*SuppressUserConversions*/true,
John McCall369371c2010-06-04 02:29:22 +00004648 /*AllowExplicitConversions*/ false,
Douglas Gregor14d0aee2011-01-27 00:58:17 +00004649 /*InOverloadResolution*/ false,
John McCallf85e1932011-06-15 23:02:42 +00004650 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4651 allowObjCWritebackConversion);
4652
4653 if (ICS.isStandard() &&
4654 ICS.Standard.Second == ICK_Writeback_Conversion) {
4655 // Objective-C ARC writeback conversion.
4656
4657 // We should copy unless we're passing to an argument explicitly
4658 // marked 'out'.
4659 bool ShouldCopy = true;
4660 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4661 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4662
4663 // If there was an lvalue adjustment, add it as a separate conversion.
4664 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4665 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4666 ImplicitConversionSequence LvalueICS;
4667 LvalueICS.setStandard();
4668 LvalueICS.Standard.setAsIdentityConversion();
4669 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4670 LvalueICS.Standard.First = ICS.Standard.First;
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004671 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
John McCallf85e1932011-06-15 23:02:42 +00004672 }
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004673
4674 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
John McCallf85e1932011-06-15 23:02:42 +00004675 } else if (ICS.isBad()) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004676 DeclAccessPair dap;
Richard Smith87c29322013-06-20 02:18:31 +00004677 if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
4678 AddZeroInitializationStep(Entity.getType());
4679 } else if (Initializer->getType() == Context.OverloadTy &&
4680 !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
4681 false, dap))
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004682 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
Douglas Gregor8e960432010-11-08 03:40:48 +00004683 else
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004684 SetFailed(InitializationSequence::FK_ConversionFailed);
John McCallf85e1932011-06-15 23:02:42 +00004685 } else {
Richard Smith13b228d2013-09-21 21:19:19 +00004686 AddConversionSequenceStep(ICS, Entity.getType(), TopLevelOfInitList);
John McCall856d3792011-06-16 23:24:51 +00004687
Rafael Espindola12ce0a02011-07-14 22:58:04 +00004688 MaybeProduceObjCObject(S, *this, Entity);
Douglas Gregor8e960432010-11-08 03:40:48 +00004689 }
Douglas Gregor20093b42009-12-09 23:02:17 +00004690}
4691
4692InitializationSequence::~InitializationSequence() {
Chris Lattner5f9e2722011-07-23 10:55:15 +00004693 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
Douglas Gregor20093b42009-12-09 23:02:17 +00004694 StepEnd = Steps.end();
4695 Step != StepEnd; ++Step)
4696 Step->Destroy();
4697}
4698
4699//===----------------------------------------------------------------------===//
4700// Perform initialization
4701//===----------------------------------------------------------------------===//
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004702static Sema::AssignmentAction
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00004703getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004704 switch(Entity.getKind()) {
4705 case InitializedEntity::EK_Variable:
4706 case InitializedEntity::EK_New:
Douglas Gregora3998bd2010-12-02 21:47:04 +00004707 case InitializedEntity::EK_Exception:
4708 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004709 case InitializedEntity::EK_Delegating:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004710 return Sema::AA_Initializing;
4711
4712 case InitializedEntity::EK_Parameter:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004713 if (Entity.getDecl() &&
Douglas Gregor688fc9b2010-04-21 23:24:10 +00004714 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4715 return Sema::AA_Sending;
4716
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004717 return Sema::AA_Passing;
4718
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00004719 case InitializedEntity::EK_Parameter_CF_Audited:
4720 if (Entity.getDecl() &&
4721 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4722 return Sema::AA_Sending;
4723
4724 return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
4725
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004726 case InitializedEntity::EK_Result:
4727 return Sema::AA_Returning;
4728
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004729 case InitializedEntity::EK_Temporary:
Fariborz Jahanianf5200d62013-07-11 19:13:34 +00004730 case InitializedEntity::EK_RelatedResult:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004731 // FIXME: Can we tell apart casting vs. converting?
4732 return Sema::AA_Casting;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004733
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004734 case InitializedEntity::EK_Member:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004735 case InitializedEntity::EK_ArrayElement:
4736 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004737 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004738 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004739 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004740 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004741 return Sema::AA_Initializing;
4742 }
4743
David Blaikie7530c032012-01-17 06:56:22 +00004744 llvm_unreachable("Invalid EntityKind!");
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004745}
4746
Richard Smith774d8b42013-01-08 00:08:23 +00004747/// \brief Whether we should bind a created object as a temporary when
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004748/// initializing the given entity.
Douglas Gregor2f599792010-04-02 18:24:57 +00004749static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004750 switch (Entity.getKind()) {
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004751 case InitializedEntity::EK_ArrayElement:
4752 case InitializedEntity::EK_Member:
Douglas Gregor2f599792010-04-02 18:24:57 +00004753 case InitializedEntity::EK_Result:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004754 case InitializedEntity::EK_New:
4755 case InitializedEntity::EK_Variable:
4756 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004757 case InitializedEntity::EK_Delegating:
Anders Carlssond3d824d2010-01-23 04:34:47 +00004758 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004759 case InitializedEntity::EK_ComplexElement:
Anders Carlssona508b7d2010-02-06 23:23:06 +00004760 case InitializedEntity::EK_Exception:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004761 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004762 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00004763 case InitializedEntity::EK_CompoundLiteralInit:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004764 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004765
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004766 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004767 case InitializedEntity::EK_Parameter_CF_Audited:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004768 case InitializedEntity::EK_Temporary:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004769 case InitializedEntity::EK_RelatedResult:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004770 return true;
4771 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004772
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004773 llvm_unreachable("missed an InitializedEntity kind?");
4774}
4775
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004776/// \brief Whether the given entity, when initialized with an object
4777/// created for that initialization, requires destruction.
4778static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4779 switch (Entity.getKind()) {
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004780 case InitializedEntity::EK_Result:
4781 case InitializedEntity::EK_New:
4782 case InitializedEntity::EK_Base:
Sean Hunt059ce0d2011-05-01 07:04:31 +00004783 case InitializedEntity::EK_Delegating:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004784 case InitializedEntity::EK_VectorElement:
Eli Friedman0c706c22011-09-19 23:17:44 +00004785 case InitializedEntity::EK_ComplexElement:
Fariborz Jahanian310b1c42010-06-07 16:14:00 +00004786 case InitializedEntity::EK_BlockElement:
Douglas Gregor47736542012-02-15 16:57:26 +00004787 case InitializedEntity::EK_LambdaCapture:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004788 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004789
Richard Smith774d8b42013-01-08 00:08:23 +00004790 case InitializedEntity::EK_Member:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004791 case InitializedEntity::EK_Variable:
4792 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004793 case InitializedEntity::EK_Parameter_CF_Audited:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004794 case InitializedEntity::EK_Temporary:
4795 case InitializedEntity::EK_ArrayElement:
4796 case InitializedEntity::EK_Exception:
Jordan Rose2624b812013-05-06 16:48:12 +00004797 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004798 case InitializedEntity::EK_RelatedResult:
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004799 return true;
4800 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004801
4802 llvm_unreachable("missed an InitializedEntity kind?");
Douglas Gregor4154e0b2010-04-24 23:45:46 +00004803}
4804
Richard Smith83da2e72011-10-19 16:55:56 +00004805/// \brief Look for copy and move constructors and constructor templates, for
4806/// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4807static void LookupCopyAndMoveConstructors(Sema &S,
4808 OverloadCandidateSet &CandidateSet,
4809 CXXRecordDecl *Class,
4810 Expr *CurInitExpr) {
David Blaikie3bc93e32012-12-19 00:45:41 +00004811 DeclContext::lookup_result R = S.LookupConstructors(Class);
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004812 // The container holding the constructors can under certain conditions
4813 // be changed while iterating (e.g. because of deserialization).
4814 // To be safe we copy the lookup results to a new container.
David Blaikie3bc93e32012-12-19 00:45:41 +00004815 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
Craig Topper09d19ef2013-07-04 03:08:24 +00004816 for (SmallVectorImpl<NamedDecl *>::iterator
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004817 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4818 NamedDecl *D = *CI;
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004819 CXXConstructorDecl *Constructor = nullptr;
Richard Smith83da2e72011-10-19 16:55:56 +00004820
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004821 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
Richard Smith83da2e72011-10-19 16:55:56 +00004822 // Handle copy/moveconstructors, only.
4823 if (!Constructor || Constructor->isInvalidDecl() ||
4824 !Constructor->isCopyOrMoveConstructor() ||
4825 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4826 continue;
4827
4828 DeclAccessPair FoundDecl
4829 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4830 S.AddOverloadCandidate(Constructor, FoundDecl,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004831 CurInitExpr, CandidateSet);
Richard Smith83da2e72011-10-19 16:55:56 +00004832 continue;
4833 }
4834
4835 // Handle constructor templates.
Argyrios Kyrtzidis8682b932012-11-13 05:07:23 +00004836 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
Richard Smith83da2e72011-10-19 16:55:56 +00004837 if (ConstructorTmpl->isInvalidDecl())
4838 continue;
4839
4840 Constructor = cast<CXXConstructorDecl>(
4841 ConstructorTmpl->getTemplatedDecl());
4842 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4843 continue;
4844
4845 // FIXME: Do we need to limit this to copy-constructor-like
4846 // candidates?
4847 DeclAccessPair FoundDecl
4848 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004849 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, nullptr,
Ahmed Charles13a140c2012-02-25 11:00:22 +00004850 CurInitExpr, CandidateSet, true);
Richard Smith83da2e72011-10-19 16:55:56 +00004851 }
4852}
4853
4854/// \brief Get the location at which initialization diagnostics should appear.
4855static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4856 Expr *Initializer) {
4857 switch (Entity.getKind()) {
4858 case InitializedEntity::EK_Result:
4859 return Entity.getReturnLoc();
4860
4861 case InitializedEntity::EK_Exception:
4862 return Entity.getThrowLoc();
4863
4864 case InitializedEntity::EK_Variable:
4865 return Entity.getDecl()->getLocation();
4866
Douglas Gregor47736542012-02-15 16:57:26 +00004867 case InitializedEntity::EK_LambdaCapture:
4868 return Entity.getCaptureLoc();
4869
Richard Smith83da2e72011-10-19 16:55:56 +00004870 case InitializedEntity::EK_ArrayElement:
4871 case InitializedEntity::EK_Member:
4872 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00004873 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith83da2e72011-10-19 16:55:56 +00004874 case InitializedEntity::EK_Temporary:
4875 case InitializedEntity::EK_New:
4876 case InitializedEntity::EK_Base:
4877 case InitializedEntity::EK_Delegating:
4878 case InitializedEntity::EK_VectorElement:
4879 case InitializedEntity::EK_ComplexElement:
4880 case InitializedEntity::EK_BlockElement:
Jordan Rose2624b812013-05-06 16:48:12 +00004881 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00004882 case InitializedEntity::EK_RelatedResult:
Richard Smith83da2e72011-10-19 16:55:56 +00004883 return Initializer->getLocStart();
4884 }
4885 llvm_unreachable("missed an InitializedEntity kind?");
4886}
4887
Douglas Gregor523d46a2010-04-18 07:40:54 +00004888/// \brief Make a (potentially elidable) temporary copy of the object
4889/// provided by the given initializer by calling the appropriate copy
4890/// constructor.
4891///
4892/// \param S The Sema object used for type-checking.
4893///
Abramo Bagnara63e7d252011-01-27 19:55:10 +00004894/// \param T The type of the temporary object, which must either be
Douglas Gregor523d46a2010-04-18 07:40:54 +00004895/// the type of the initializer expression or a superclass thereof.
4896///
James Dennett1dfbd922012-06-14 21:40:34 +00004897/// \param Entity The entity being initialized.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004898///
4899/// \param CurInit The initializer expression.
4900///
4901/// \param IsExtraneousCopy Whether this is an "extraneous" copy that
4902/// is permitted in C++03 (but not C++0x) when binding a reference to
4903/// an rvalue.
4904///
4905/// \returns An expression that copies the initializer expression into
4906/// a temporary object, or an error expression if a copy could not be
4907/// created.
John McCall60d7b3a2010-08-24 06:29:42 +00004908static ExprResult CopyObject(Sema &S,
Douglas Gregor8fcc5162010-09-12 08:07:23 +00004909 QualType T,
4910 const InitializedEntity &Entity,
4911 ExprResult CurInit,
4912 bool IsExtraneousCopy) {
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004913 // Determine which class type we're copying to.
Anders Carlsson1b36a2f2010-01-24 00:19:41 +00004914 Expr *CurInitExpr = (Expr *)CurInit.get();
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004915 CXXRecordDecl *Class = nullptr;
Douglas Gregor523d46a2010-04-18 07:40:54 +00004916 if (const RecordType *Record = T->getAs<RecordType>())
Douglas Gregor2f599792010-04-02 18:24:57 +00004917 Class = cast<CXXRecordDecl>(Record->getDecl());
4918 if (!Class)
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004919 return CurInit;
Douglas Gregor2f599792010-04-02 18:24:57 +00004920
Douglas Gregorf5d8f462011-01-21 18:05:27 +00004921 // C++0x [class.copy]p32:
Douglas Gregor2f599792010-04-02 18:24:57 +00004922 // When certain criteria are met, an implementation is allowed to
4923 // omit the copy/move construction of a class object, even if the
4924 // copy/move constructor and/or destructor for the object have
4925 // side effects. [...]
4926 // - when a temporary class object that has not been bound to a
4927 // reference (12.2) would be copied/moved to a class object
4928 // with the same cv-unqualified type, the copy/move operation
4929 // can be omitted by constructing the temporary object
4930 // directly into the target of the omitted copy/move
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004931 //
Douglas Gregor2f599792010-04-02 18:24:57 +00004932 // Note that the other three bullets are handled elsewhere. Copy
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004933 // elision for return statements and throw expressions are handled as part
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004934 // of constructor initialization, while copy elision for exception handlers
Douglas Gregor3c9034c2010-05-15 00:13:29 +00004935 // is handled by the run-time.
John McCall558d2ab2010-09-15 10:14:12 +00004936 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
Richard Smith83da2e72011-10-19 16:55:56 +00004937 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004938
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004939 // Make sure that the type we are copying is complete.
Douglas Gregord10099e2012-05-04 16:32:21 +00004940 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004941 return CurInit;
Douglas Gregorf86fcb32010-04-24 21:09:25 +00004942
Douglas Gregorcc15f012011-01-21 19:38:21 +00004943 // Perform overload resolution using the class's copy/move constructors.
Richard Smith83da2e72011-10-19 16:55:56 +00004944 // Only consider constructors and constructor templates. Per
4945 // C++0x [dcl.init]p16, second bullet to class types, this initialization
4946 // is direct-initialization.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07004947 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
Richard Smith83da2e72011-10-19 16:55:56 +00004948 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004949
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00004950 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4951
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004952 OverloadCandidateSet::iterator Best;
Chandler Carruth25ca4212011-02-25 19:41:05 +00004953 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004954 case OR_Success:
4955 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004956
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004957 case OR_No_Viable_Function:
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004958 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
4959 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
4960 : diag::err_temp_copy_no_viable)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004961 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004962 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004963 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004964 if (!IsExtraneousCopy || S.isSFINAEContext())
John McCallf312b1e2010-08-26 23:41:50 +00004965 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00004966 return CurInit;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004967
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004968 case OR_Ambiguous:
4969 S.Diag(Loc, diag::err_temp_copy_ambiguous)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004970 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004971 << CurInitExpr->getSourceRange();
Ahmed Charles13a140c2012-02-25 11:00:22 +00004972 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
John McCallf312b1e2010-08-26 23:41:50 +00004973 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004974
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004975 case OR_Deleted:
4976 S.Diag(Loc, diag::err_temp_copy_deleted)
Douglas Gregor7abfbdb2009-12-19 03:01:41 +00004977 << (int)Entity.getKind() << CurInitExpr->getType()
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004978 << CurInitExpr->getSourceRange();
Richard Smith6c4c36c2012-03-30 20:53:28 +00004979 S.NoteDeletedFunction(Best->Function);
John McCallf312b1e2010-08-26 23:41:50 +00004980 return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00004981 }
4982
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004983 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00004984 SmallVector<Expr*, 8> ConstructorArgs;
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00004985 CurInit.release(); // Ownership transferred into MultiExprArg, below.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004986
Anders Carlsson9a68a672010-04-21 18:47:17 +00004987 S.CheckConstructorAccess(Loc, Constructor, Entity,
Jeffrey Yasskin57d12fd2010-06-07 15:58:05 +00004988 Best->FoundDecl.getAccess(), IsExtraneousCopy);
Douglas Gregor523d46a2010-04-18 07:40:54 +00004989
4990 if (IsExtraneousCopy) {
4991 // If this is a totally extraneous copy for C++03 reference
4992 // binding purposes, just return the original initialization
Douglas Gregor2559a702010-04-18 07:57:34 +00004993 // expression. We don't generate an (elided) copy operation here
4994 // because doing so would require us to pass down a flag to avoid
4995 // infinite recursion, where each step adds another extraneous,
4996 // elidable copy.
Douglas Gregor523d46a2010-04-18 07:40:54 +00004997
Douglas Gregor2559a702010-04-18 07:57:34 +00004998 // Instantiate the default arguments of any extra parameters in
4999 // the selected copy constructor, as if we were going to create a
5000 // proper call to the copy constructor.
5001 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5002 ParmVarDecl *Parm = Constructor->getParamDecl(I);
5003 if (S.RequireCompleteType(Loc, Parm->getType(),
Douglas Gregord10099e2012-05-04 16:32:21 +00005004 diag::err_call_incomplete_argument))
Douglas Gregor2559a702010-04-18 07:57:34 +00005005 break;
5006
5007 // Build the default argument expression; we don't actually care
5008 // if this succeeds or not, because this routine will complain
5009 // if there was a problem.
5010 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5011 }
5012
Douglas Gregor523d46a2010-04-18 07:40:54 +00005013 return S.Owned(CurInitExpr);
5014 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005015
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00005016 // Determine the arguments required to actually perform the
Douglas Gregor523d46a2010-04-18 07:40:54 +00005017 // constructor call (we might have derived-to-base conversions, or
5018 // the copy constructor may have default arguments).
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00005019 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005020 return ExprError();
Douglas Gregor3fbaf3e2010-04-17 22:01:05 +00005021
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00005022 // Actually perform the constructor call.
5023 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005024 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005025 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005026 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005027 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005028 CXXConstructExpr::CK_Complete,
5029 SourceRange());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005030
Douglas Gregorb86cf0c2010-04-25 00:55:24 +00005031 // If we're supposed to bind temporaries, do so.
5032 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5033 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005034 return CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005035}
Douglas Gregor20093b42009-12-09 23:02:17 +00005036
Richard Smith83da2e72011-10-19 16:55:56 +00005037/// \brief Check whether elidable copy construction for binding a reference to
5038/// a temporary would have succeeded if we were building in C++98 mode, for
5039/// -Wc++98-compat.
5040static void CheckCXX98CompatAccessibleCopy(Sema &S,
5041 const InitializedEntity &Entity,
5042 Expr *CurInitExpr) {
Richard Smith80ad52f2013-01-02 11:42:31 +00005043 assert(S.getLangOpts().CPlusPlus11);
Richard Smith83da2e72011-10-19 16:55:56 +00005044
5045 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5046 if (!Record)
5047 return;
5048
5049 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5050 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc)
5051 == DiagnosticsEngine::Ignored)
5052 return;
5053
5054 // Find constructors which would have been considered.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005055 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
Richard Smith83da2e72011-10-19 16:55:56 +00005056 LookupCopyAndMoveConstructors(
5057 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5058
5059 // Perform overload resolution.
5060 OverloadCandidateSet::iterator Best;
5061 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5062
5063 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5064 << OR << (int)Entity.getKind() << CurInitExpr->getType()
5065 << CurInitExpr->getSourceRange();
5066
5067 switch (OR) {
5068 case OR_Success:
5069 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
John McCallb9abd8722012-04-07 03:04:20 +00005070 Entity, Best->FoundDecl.getAccess(), Diag);
Richard Smith83da2e72011-10-19 16:55:56 +00005071 // FIXME: Check default arguments as far as that's possible.
5072 break;
5073
5074 case OR_No_Viable_Function:
5075 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00005076 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00005077 break;
5078
5079 case OR_Ambiguous:
5080 S.Diag(Loc, Diag);
Ahmed Charles13a140c2012-02-25 11:00:22 +00005081 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
Richard Smith83da2e72011-10-19 16:55:56 +00005082 break;
5083
5084 case OR_Deleted:
5085 S.Diag(Loc, Diag);
Richard Smith6c4c36c2012-03-30 20:53:28 +00005086 S.NoteDeletedFunction(Best->Function);
Richard Smith83da2e72011-10-19 16:55:56 +00005087 break;
5088 }
5089}
5090
Douglas Gregora41a8c52010-04-22 00:20:18 +00005091void InitializationSequence::PrintInitLocationNote(Sema &S,
5092 const InitializedEntity &Entity) {
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005093 if (Entity.isParameterKind() && Entity.getDecl()) {
Douglas Gregora41a8c52010-04-22 00:20:18 +00005094 if (Entity.getDecl()->getLocation().isInvalid())
5095 return;
5096
5097 if (Entity.getDecl()->getDeclName())
5098 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5099 << Entity.getDecl()->getDeclName();
5100 else
5101 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5102 }
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005103 else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5104 Entity.getMethodDecl())
5105 S.Diag(Entity.getMethodDecl()->getLocation(),
5106 diag::note_method_return_type_change)
5107 << Entity.getMethodDecl()->getDeclName();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005108}
5109
Sebastian Redl3b802322011-07-14 19:07:55 +00005110static bool isReferenceBinding(const InitializationSequence::Step &s) {
5111 return s.Kind == InitializationSequence::SK_BindReference ||
5112 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5113}
5114
Jordan Rose2624b812013-05-06 16:48:12 +00005115/// Returns true if the parameters describe a constructor initialization of
5116/// an explicit temporary object, e.g. "Point(x, y)".
5117static bool isExplicitTemporary(const InitializedEntity &Entity,
5118 const InitializationKind &Kind,
5119 unsigned NumArgs) {
5120 switch (Entity.getKind()) {
5121 case InitializedEntity::EK_Temporary:
5122 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005123 case InitializedEntity::EK_RelatedResult:
Jordan Rose2624b812013-05-06 16:48:12 +00005124 break;
5125 default:
5126 return false;
5127 }
5128
5129 switch (Kind.getKind()) {
5130 case InitializationKind::IK_DirectList:
5131 return true;
5132 // FIXME: Hack to work around cast weirdness.
5133 case InitializationKind::IK_Direct:
5134 case InitializationKind::IK_Value:
5135 return NumArgs != 1;
5136 default:
5137 return false;
5138 }
5139}
5140
Sebastian Redl10f04a62011-12-22 14:44:04 +00005141static ExprResult
5142PerformConstructorInitialization(Sema &S,
5143 const InitializedEntity &Entity,
5144 const InitializationKind &Kind,
5145 MultiExprArg Args,
5146 const InitializationSequence::Step& Step,
Richard Smithc83c2302012-12-19 01:39:02 +00005147 bool &ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00005148 bool IsListInitialization,
5149 SourceLocation LBraceLoc,
5150 SourceLocation RBraceLoc) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005151 unsigned NumArgs = Args.size();
5152 CXXConstructorDecl *Constructor
5153 = cast<CXXConstructorDecl>(Step.Function.Function);
5154 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5155
5156 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005157 SmallVector<Expr*, 8> ConstructorArgs;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005158 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5159 ? Kind.getEqualLoc()
5160 : Kind.getLocation();
5161
5162 if (Kind.getKind() == InitializationKind::IK_Default) {
5163 // Force even a trivial, implicit default constructor to be
5164 // semantically checked. We do this explicitly because we don't build
5165 // the definition for completely trivial constructors.
Matt Beaumont-Gay28e47022012-02-24 08:37:56 +00005166 assert(Constructor->getParent() && "No parent class for constructor.");
Sebastian Redl10f04a62011-12-22 14:44:04 +00005167 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
Douglas Gregor5d86f612012-02-24 07:48:37 +00005168 Constructor->isTrivial() && !Constructor->isUsed(false))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005169 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5170 }
5171
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005172 ExprResult CurInit = S.Owned((Expr *)nullptr);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005173
Douglas Gregored878af2012-02-24 23:56:31 +00005174 // C++ [over.match.copy]p1:
5175 // - When initializing a temporary to be bound to the first parameter
5176 // of a constructor that takes a reference to possibly cv-qualified
5177 // T as its first argument, called with a single argument in the
5178 // context of direct-initialization, explicit conversion functions
5179 // are also considered.
5180 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5181 Args.size() == 1 &&
5182 Constructor->isCopyOrMoveConstructor();
5183
Sebastian Redl10f04a62011-12-22 14:44:04 +00005184 // Determine the arguments required to actually perform the constructor
5185 // call.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005186 if (S.CompleteConstructorCall(Constructor, Args,
Douglas Gregored878af2012-02-24 23:56:31 +00005187 Loc, ConstructorArgs,
Richard Smitha4dc51b2013-02-05 05:52:24 +00005188 AllowExplicitConv,
5189 IsListInitialization))
Sebastian Redl10f04a62011-12-22 14:44:04 +00005190 return ExprError();
5191
5192
Jordan Rose2624b812013-05-06 16:48:12 +00005193 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
Sebastian Redl10f04a62011-12-22 14:44:04 +00005194 // An explicitly-constructed temporary, e.g., X(1, 2).
Eli Friedman5f2987c2012-02-02 03:46:19 +00005195 S.MarkFunctionReferenced(Loc, Constructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005196 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5197 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005198
5199 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5200 if (!TSInfo)
5201 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
Enea Zaffanella1245a542013-09-07 05:49:53 +00005202 SourceRange ParenOrBraceRange =
5203 (Kind.getKind() == InitializationKind::IK_DirectList)
5204 ? SourceRange(LBraceLoc, RBraceLoc)
5205 : Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005206
Richard Smithc83c2302012-12-19 01:39:02 +00005207 CurInit = S.Owned(
5208 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor,
5209 TSInfo, ConstructorArgs,
Enea Zaffanella1245a542013-09-07 05:49:53 +00005210 ParenOrBraceRange,
Richard Smithc83c2302012-12-19 01:39:02 +00005211 HadMultipleCandidates,
Enea Zaffanella14dcaa92013-09-07 11:22:02 +00005212 IsListInitialization,
Richard Smithc83c2302012-12-19 01:39:02 +00005213 ConstructorInitRequiresZeroInit));
Sebastian Redl10f04a62011-12-22 14:44:04 +00005214 } else {
5215 CXXConstructExpr::ConstructionKind ConstructKind =
5216 CXXConstructExpr::CK_Complete;
5217
5218 if (Entity.getKind() == InitializedEntity::EK_Base) {
5219 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5220 CXXConstructExpr::CK_VirtualBase :
5221 CXXConstructExpr::CK_NonVirtualBase;
5222 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5223 ConstructKind = CXXConstructExpr::CK_Delegating;
5224 }
5225
Stephen Hines651f13c2014-04-23 16:59:28 -07005226 // Only get the parenthesis or brace range if it is a list initialization or
5227 // direct construction.
5228 SourceRange ParenOrBraceRange;
5229 if (IsListInitialization)
5230 ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5231 else if (Kind.getKind() == InitializationKind::IK_Direct)
5232 ParenOrBraceRange = Kind.getParenRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005233
5234 // If the entity allows NRVO, mark the construction as elidable
5235 // unconditionally.
5236 if (Entity.allowsNRVO())
5237 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5238 Constructor, /*Elidable=*/true,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005239 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005240 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005241 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005242 ConstructorInitRequiresZeroInit,
5243 ConstructKind,
Stephen Hines651f13c2014-04-23 16:59:28 -07005244 ParenOrBraceRange);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005245 else
5246 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5247 Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005248 ConstructorArgs,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005249 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005250 IsListInitialization,
Sebastian Redl10f04a62011-12-22 14:44:04 +00005251 ConstructorInitRequiresZeroInit,
5252 ConstructKind,
Stephen Hines651f13c2014-04-23 16:59:28 -07005253 ParenOrBraceRange);
Sebastian Redl10f04a62011-12-22 14:44:04 +00005254 }
5255 if (CurInit.isInvalid())
5256 return ExprError();
5257
5258 // Only check access if all of that succeeded.
5259 S.CheckConstructorAccess(Loc, Constructor, Entity,
5260 Step.Function.FoundDecl.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005261 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5262 return ExprError();
Sebastian Redl10f04a62011-12-22 14:44:04 +00005263
5264 if (shouldBindAsTemporary(Entity))
Richard Smith7c3e6152013-06-12 22:31:48 +00005265 CurInit = S.MaybeBindToTemporary(CurInit.take());
Sebastian Redl10f04a62011-12-22 14:44:04 +00005266
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005267 return CurInit;
Sebastian Redl10f04a62011-12-22 14:44:04 +00005268}
5269
Richard Smith36d02af2012-06-04 22:27:30 +00005270/// Determine whether the specified InitializedEntity definitely has a lifetime
5271/// longer than the current full-expression. Conservatively returns false if
5272/// it's unclear.
5273static bool
5274InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5275 const InitializedEntity *Top = &Entity;
5276 while (Top->getParent())
5277 Top = Top->getParent();
5278
5279 switch (Top->getKind()) {
5280 case InitializedEntity::EK_Variable:
5281 case InitializedEntity::EK_Result:
5282 case InitializedEntity::EK_Exception:
5283 case InitializedEntity::EK_Member:
5284 case InitializedEntity::EK_New:
5285 case InitializedEntity::EK_Base:
5286 case InitializedEntity::EK_Delegating:
5287 return true;
5288
5289 case InitializedEntity::EK_ArrayElement:
5290 case InitializedEntity::EK_VectorElement:
5291 case InitializedEntity::EK_BlockElement:
5292 case InitializedEntity::EK_ComplexElement:
5293 // Could not determine what the full initialization is. Assume it might not
5294 // outlive the full-expression.
5295 return false;
5296
5297 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005298 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith36d02af2012-06-04 22:27:30 +00005299 case InitializedEntity::EK_Temporary:
5300 case InitializedEntity::EK_LambdaCapture:
Jordan Rose2624b812013-05-06 16:48:12 +00005301 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005302 case InitializedEntity::EK_RelatedResult:
Richard Smith36d02af2012-06-04 22:27:30 +00005303 // The entity being initialized might not outlive the full-expression.
5304 return false;
5305 }
5306
5307 llvm_unreachable("unknown entity kind");
5308}
5309
Richard Smith211c8dd2013-06-05 00:46:14 +00005310/// Determine the declaration which an initialized entity ultimately refers to,
5311/// for the purpose of lifetime-extending a temporary bound to a reference in
5312/// the initialization of \p Entity.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005313static const InitializedEntity *getEntityForTemporaryLifetimeExtension(
5314 const InitializedEntity *Entity,
5315 const InitializedEntity *FallbackDecl = nullptr) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005316 // C++11 [class.temporary]p5:
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005317 switch (Entity->getKind()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005318 case InitializedEntity::EK_Variable:
5319 // The temporary [...] persists for the lifetime of the reference
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005320 return Entity;
Richard Smith211c8dd2013-06-05 00:46:14 +00005321
5322 case InitializedEntity::EK_Member:
5323 // For subobjects, we look at the complete object.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005324 if (Entity->getParent())
5325 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5326 Entity);
Richard Smith211c8dd2013-06-05 00:46:14 +00005327
5328 // except:
5329 // -- A temporary bound to a reference member in a constructor's
5330 // ctor-initializer persists until the constructor exits.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005331 return Entity;
Richard Smith211c8dd2013-06-05 00:46:14 +00005332
5333 case InitializedEntity::EK_Parameter:
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005334 case InitializedEntity::EK_Parameter_CF_Audited:
Richard Smith211c8dd2013-06-05 00:46:14 +00005335 // -- A temporary bound to a reference parameter in a function call
5336 // persists until the completion of the full-expression containing
5337 // the call.
5338 case InitializedEntity::EK_Result:
5339 // -- The lifetime of a temporary bound to the returned value in a
5340 // function return statement is not extended; the temporary is
5341 // destroyed at the end of the full-expression in the return statement.
5342 case InitializedEntity::EK_New:
5343 // -- A temporary bound to a reference in a new-initializer persists
5344 // until the completion of the full-expression containing the
5345 // new-initializer.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005346 return nullptr;
Richard Smith211c8dd2013-06-05 00:46:14 +00005347
5348 case InitializedEntity::EK_Temporary:
5349 case InitializedEntity::EK_CompoundLiteralInit:
Fariborz Jahanianf92a5092013-07-11 16:48:06 +00005350 case InitializedEntity::EK_RelatedResult:
Richard Smith211c8dd2013-06-05 00:46:14 +00005351 // We don't yet know the storage duration of the surrounding temporary.
5352 // Assume it's got full-expression duration for now, it will patch up our
5353 // storage duration if that's not correct.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005354 return nullptr;
Richard Smith211c8dd2013-06-05 00:46:14 +00005355
5356 case InitializedEntity::EK_ArrayElement:
5357 // For subobjects, we look at the complete object.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005358 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5359 FallbackDecl);
Richard Smith211c8dd2013-06-05 00:46:14 +00005360
5361 case InitializedEntity::EK_Base:
5362 case InitializedEntity::EK_Delegating:
5363 // We can reach this case for aggregate initialization in a constructor:
5364 // struct A { int &&r; };
5365 // struct B : A { B() : A{0} {} };
5366 // In this case, use the innermost field decl as the context.
5367 return FallbackDecl;
5368
5369 case InitializedEntity::EK_BlockElement:
5370 case InitializedEntity::EK_LambdaCapture:
5371 case InitializedEntity::EK_Exception:
5372 case InitializedEntity::EK_VectorElement:
5373 case InitializedEntity::EK_ComplexElement:
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005374 return nullptr;
Richard Smith211c8dd2013-06-05 00:46:14 +00005375 }
Benjamin Kramer6f773e82013-06-05 15:37:50 +00005376 llvm_unreachable("unknown entity kind");
Richard Smith211c8dd2013-06-05 00:46:14 +00005377}
5378
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005379static void performLifetimeExtension(Expr *Init,
5380 const InitializedEntity *ExtendingEntity);
Richard Smith211c8dd2013-06-05 00:46:14 +00005381
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.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005385static bool
5386performReferenceExtension(Expr *Init,
5387 const InitializedEntity *ExtendingEntity) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005388 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5389 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5390 // This is just redundant braces around an initializer. Step over it.
5391 Init = ILE->getInit(0);
5392 }
5393 }
5394
Richard Smithd6b69872013-06-15 00:30:29 +00005395 // Walk past any constructs which we can lifetime-extend across.
5396 Expr *Old;
5397 do {
5398 Old = Init;
5399
5400 // Step over any subobject adjustments; we may have a materialized
5401 // temporary inside them.
5402 SmallVector<const Expr *, 2> CommaLHSs;
5403 SmallVector<SubobjectAdjustment, 2> Adjustments;
5404 Init = const_cast<Expr *>(
5405 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5406
5407 // Per current approach for DR1376, look through casts to reference type
5408 // when performing lifetime extension.
5409 if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5410 if (CE->getSubExpr()->isGLValue())
5411 Init = CE->getSubExpr();
5412
5413 // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5414 // It's unclear if binding a reference to that xvalue extends the array
5415 // temporary.
5416 } while (Init != Old);
5417
Richard Smith211c8dd2013-06-05 00:46:14 +00005418 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5419 // Update the storage duration of the materialized temporary.
5420 // FIXME: Rebuild the expression instead of mutating it.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005421 ME->setExtendingDecl(ExtendingEntity->getDecl(),
5422 ExtendingEntity->allocateManglingNumber());
5423 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
Richard Smithd6b69872013-06-15 00:30:29 +00005424 return true;
Richard Smith211c8dd2013-06-05 00:46:14 +00005425 }
Richard Smithd6b69872013-06-15 00:30:29 +00005426
5427 return false;
Richard Smith211c8dd2013-06-05 00:46:14 +00005428}
5429
5430/// Update a prvalue expression that is going to be materialized as a
5431/// lifetime-extended temporary.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005432static void performLifetimeExtension(Expr *Init,
5433 const InitializedEntity *ExtendingEntity) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005434 // Dig out the expression which constructs the extended temporary.
5435 SmallVector<const Expr *, 2> CommaLHSs;
5436 SmallVector<SubobjectAdjustment, 2> Adjustments;
5437 Init = const_cast<Expr *>(
5438 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5439
Richard Smith8a07cd32013-06-12 20:42:33 +00005440 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5441 Init = BTE->getSubExpr();
5442
Richard Smith7c3e6152013-06-12 22:31:48 +00005443 if (CXXStdInitializerListExpr *ILE =
Richard Smithd6b69872013-06-15 00:30:29 +00005444 dyn_cast<CXXStdInitializerListExpr>(Init)) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005445 performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
Richard Smithd6b69872013-06-15 00:30:29 +00005446 return;
5447 }
Richard Smith7c3e6152013-06-12 22:31:48 +00005448
Richard Smith211c8dd2013-06-05 00:46:14 +00005449 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
Richard Smith7c3e6152013-06-12 22:31:48 +00005450 if (ILE->getType()->isArrayType()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005451 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005452 performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
Richard Smith211c8dd2013-06-05 00:46:14 +00005453 return;
5454 }
5455
Richard Smith7c3e6152013-06-12 22:31:48 +00005456 if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
Richard Smith211c8dd2013-06-05 00:46:14 +00005457 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5458
5459 // If we lifetime-extend a braced initializer which is initializing an
5460 // aggregate, and that aggregate contains reference members which are
5461 // bound to temporaries, those temporaries are also lifetime-extended.
5462 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5463 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005464 performReferenceExtension(ILE->getInit(0), ExtendingEntity);
Richard Smith211c8dd2013-06-05 00:46:14 +00005465 else {
5466 unsigned Index = 0;
Stephen Hines651f13c2014-04-23 16:59:28 -07005467 for (const auto *I : RD->fields()) {
Richard Smith3c3af142013-07-01 06:08:20 +00005468 if (Index >= ILE->getNumInits())
5469 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00005470 if (I->isUnnamedBitfield())
5471 continue;
Richard Smith5771aab2013-06-27 22:54:33 +00005472 Expr *SubInit = ILE->getInit(Index);
Richard Smith211c8dd2013-06-05 00:46:14 +00005473 if (I->getType()->isReferenceType())
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005474 performReferenceExtension(SubInit, ExtendingEntity);
Richard Smith5771aab2013-06-27 22:54:33 +00005475 else if (isa<InitListExpr>(SubInit) ||
5476 isa<CXXStdInitializerListExpr>(SubInit))
Richard Smith211c8dd2013-06-05 00:46:14 +00005477 // This may be either aggregate-initialization of a member or
5478 // initialization of a std::initializer_list object. Either way,
5479 // we should recursively lifetime-extend that initializer.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005480 performLifetimeExtension(SubInit, ExtendingEntity);
Richard Smith211c8dd2013-06-05 00:46:14 +00005481 ++Index;
5482 }
5483 }
5484 }
5485 }
5486}
5487
Richard Smith7c3e6152013-06-12 22:31:48 +00005488static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5489 const Expr *Init, bool IsInitializerList,
5490 const ValueDecl *ExtendingDecl) {
5491 // Warn if a field lifetime-extends a temporary.
5492 if (isa<FieldDecl>(ExtendingDecl)) {
5493 if (IsInitializerList) {
5494 S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5495 << /*at end of constructor*/true;
5496 return;
5497 }
5498
5499 bool IsSubobjectMember = false;
5500 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5501 Ent = Ent->getParent()) {
5502 if (Ent->getKind() != InitializedEntity::EK_Base) {
5503 IsSubobjectMember = true;
5504 break;
5505 }
5506 }
5507 S.Diag(Init->getExprLoc(),
5508 diag::warn_bind_ref_member_to_temporary)
5509 << ExtendingDecl << Init->getSourceRange()
5510 << IsSubobjectMember << IsInitializerList;
5511 if (IsSubobjectMember)
5512 S.Diag(ExtendingDecl->getLocation(),
5513 diag::note_ref_subobject_of_member_declared_here);
5514 else
5515 S.Diag(ExtendingDecl->getLocation(),
5516 diag::note_ref_or_ptr_member_declared_here)
5517 << /*is pointer*/false;
5518 }
5519}
5520
Richard Smith13b228d2013-09-21 21:19:19 +00005521static void DiagnoseNarrowingInInitList(Sema &S,
5522 const ImplicitConversionSequence &ICS,
5523 QualType PreNarrowingType,
5524 QualType EntityType,
5525 const Expr *PostInit);
5526
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005527ExprResult
Douglas Gregor20093b42009-12-09 23:02:17 +00005528InitializationSequence::Perform(Sema &S,
5529 const InitializedEntity &Entity,
5530 const InitializationKind &Kind,
John McCallf312b1e2010-08-26 23:41:50 +00005531 MultiExprArg Args,
Douglas Gregord87b61f2009-12-10 17:56:55 +00005532 QualType *ResultType) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00005533 if (Failed()) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00005534 Diagnose(S, Entity, Kind, Args);
John McCallf312b1e2010-08-26 23:41:50 +00005535 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005536 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005537
Sebastian Redl7491c492011-06-05 13:59:11 +00005538 if (getKind() == DependentSequence) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005539 // If the declaration is a non-dependent, incomplete array type
5540 // that has an initializer, then its type will be completed once
5541 // the initializer is instantiated.
Douglas Gregord6542d82009-12-22 15:35:07 +00005542 if (ResultType && !Entity.getType()->isDependentType() &&
Douglas Gregord87b61f2009-12-10 17:56:55 +00005543 Args.size() == 1) {
Douglas Gregord6542d82009-12-22 15:35:07 +00005544 QualType DeclType = Entity.getType();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005545 if (const IncompleteArrayType *ArrayT
5546 = S.Context.getAsIncompleteArrayType(DeclType)) {
5547 // FIXME: We don't currently have the ability to accurately
5548 // compute the length of an initializer list without
5549 // performing full type-checking of the initializer list
5550 // (since we have to determine where braces are implicitly
5551 // introduced and such). So, we fall back to making the array
5552 // type a dependently-sized array type with no specified
5553 // bound.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005554 if (isa<InitListExpr>((Expr *)Args[0])) {
Douglas Gregord87b61f2009-12-10 17:56:55 +00005555 SourceRange Brackets;
Douglas Gregord6542d82009-12-22 15:35:07 +00005556
Douglas Gregord87b61f2009-12-10 17:56:55 +00005557 // Scavange the location of the brackets from the entity, if we can.
Douglas Gregord6542d82009-12-22 15:35:07 +00005558 if (DeclaratorDecl *DD = Entity.getDecl()) {
5559 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
5560 TypeLoc TL = TInfo->getTypeLoc();
David Blaikie39e6ab42013-02-18 22:06:02 +00005561 if (IncompleteArrayTypeLoc ArrayLoc =
5562 TL.getAs<IncompleteArrayTypeLoc>())
5563 Brackets = ArrayLoc.getBracketsRange();
Douglas Gregord6542d82009-12-22 15:35:07 +00005564 }
Douglas Gregord87b61f2009-12-10 17:56:55 +00005565 }
5566
5567 *ResultType
5568 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005569 /*NumElts=*/nullptr,
Douglas Gregord87b61f2009-12-10 17:56:55 +00005570 ArrayT->getSizeModifier(),
5571 ArrayT->getIndexTypeCVRQualifiers(),
5572 Brackets);
5573 }
5574
5575 }
5576 }
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005577 if (Kind.getKind() == InitializationKind::IK_Direct &&
5578 !Kind.isExplicitCast()) {
5579 // Rebuild the ParenListExpr.
5580 SourceRange ParenRange = Kind.getParenRange();
5581 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005582 Args);
Sebastian Redl5b9cc5d2012-02-11 23:51:47 +00005583 }
Manuel Klimek0d9106f2011-06-22 20:02:16 +00005584 assert(Kind.getKind() == InitializationKind::IK_Copy ||
Douglas Gregora9b55a42012-04-04 04:06:51 +00005585 Kind.isExplicitCast() ||
5586 Kind.getKind() == InitializationKind::IK_DirectList);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005587 return ExprResult(Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00005588 }
5589
Sebastian Redl7491c492011-06-05 13:59:11 +00005590 // No steps means no initialization.
5591 if (Steps.empty())
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005592 return S.Owned((Expr *)nullptr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005593
Richard Smith80ad52f2013-01-02 11:42:31 +00005594 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005595 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00005596 !Entity.isParameterKind()) {
Richard Smith03544fc2012-04-19 06:58:00 +00005597 // Produce a C++98 compatibility warning if we are initializing a reference
5598 // from an initializer list. For parameters, we produce a better warning
5599 // elsewhere.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005600 Expr *Init = Args[0];
Richard Smith03544fc2012-04-19 06:58:00 +00005601 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
5602 << Init->getSourceRange();
5603 }
5604
Richard Smith36d02af2012-06-04 22:27:30 +00005605 // Diagnose cases where we initialize a pointer to an array temporary, and the
5606 // pointer obviously outlives the temporary.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005607 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
Richard Smith36d02af2012-06-04 22:27:30 +00005608 Entity.getType()->isPointerType() &&
5609 InitializedEntityOutlivesFullExpression(Entity)) {
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005610 Expr *Init = Args[0];
Richard Smith36d02af2012-06-04 22:27:30 +00005611 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
5612 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
5613 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
5614 << Init->getSourceRange();
5615 }
5616
Douglas Gregord6542d82009-12-22 15:35:07 +00005617 QualType DestType = Entity.getType().getNonReferenceType();
5618 // FIXME: Ugly hack around the fact that Entity.getType() is not
Eli Friedmana91eb542009-12-22 02:10:53 +00005619 // the same as Entity.getDecl()->getType() in cases involving type merging,
5620 // and we want latter when it makes sense.
Douglas Gregord87b61f2009-12-10 17:56:55 +00005621 if (ResultType)
Eli Friedmana91eb542009-12-22 02:10:53 +00005622 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
Douglas Gregord6542d82009-12-22 15:35:07 +00005623 Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005624
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005625 ExprResult CurInit = S.Owned((Expr *)nullptr);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005626
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005627 // For initialization steps that start with a single initializer,
Douglas Gregor99a2e602009-12-16 01:38:02 +00005628 // grab the only argument out the Args and place it into the "current"
5629 // initializer.
5630 switch (Steps.front().Kind) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005631 case SK_ResolveAddressOfOverloadedFunction:
5632 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005633 case SK_CastDerivedToBaseXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005634 case SK_CastDerivedToBaseLValue:
5635 case SK_BindReference:
5636 case SK_BindReferenceToTemporary:
Douglas Gregor523d46a2010-04-18 07:40:54 +00005637 case SK_ExtraneousCopyToTemporary:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005638 case SK_UserConversion:
5639 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005640 case SK_QualificationConversionXValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005641 case SK_QualificationConversionRValue:
Jordan Rose1fd1e282013-04-11 00:58:58 +00005642 case SK_LValueToRValue:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005643 case SK_ConversionSequence:
Richard Smith13b228d2013-09-21 21:19:19 +00005644 case SK_ConversionSequenceNoNarrowing:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005645 case SK_ListInitialization:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005646 case SK_UnwrapInitList:
5647 case SK_RewrapInitList:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005648 case SK_CAssignment:
Eli Friedmancfdc81a2009-12-19 08:11:05 +00005649 case SK_StringInit:
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00005650 case SK_ObjCObjectConversion:
John McCallf85e1932011-06-15 23:02:42 +00005651 case SK_ArrayInit:
Richard Smith0f163e92012-02-15 22:38:09 +00005652 case SK_ParenthesizedArrayInit:
John McCallf85e1932011-06-15 23:02:42 +00005653 case SK_PassByIndirectCopyRestore:
5654 case SK_PassByIndirectRestore:
Sebastian Redl2b916b82012-01-17 22:49:42 +00005655 case SK_ProduceObjCObject:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005656 case SK_StdInitializerList:
Guy Benyei21f18c42013-02-07 10:55:47 +00005657 case SK_OCLSamplerInit:
Guy Benyeie6b9d802013-01-20 12:31:11 +00005658 case SK_OCLZeroEvent: {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005659 assert(Args.size() == 1);
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005660 CurInit = Args[0];
John Wiegley429bb272011-04-08 18:41:53 +00005661 if (!CurInit.get()) return ExprError();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005662 break;
John McCallf6a16482010-12-04 03:47:34 +00005663 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005664
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005665 case SK_ConstructorInitialization:
Richard Smithf4bb8d02012-07-05 08:39:21 +00005666 case SK_ListConstructorCall:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005667 case SK_ZeroInitialization:
5668 break;
Douglas Gregor20093b42009-12-09 23:02:17 +00005669 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005670
5671 // Walk through the computed steps for the initialization sequence,
Douglas Gregor20093b42009-12-09 23:02:17 +00005672 // performing the specified conversions along the way.
Douglas Gregor16006c92009-12-16 18:50:27 +00005673 bool ConstructorInitRequiresZeroInit = false;
Douglas Gregor20093b42009-12-09 23:02:17 +00005674 for (step_iterator Step = step_begin(), StepEnd = step_end();
5675 Step != StepEnd; ++Step) {
5676 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005677 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005678
John Wiegley429bb272011-04-08 18:41:53 +00005679 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005680
Douglas Gregor20093b42009-12-09 23:02:17 +00005681 switch (Step->Kind) {
5682 case SK_ResolveAddressOfOverloadedFunction:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005683 // Overload resolution determined which function invoke; update the
Douglas Gregor20093b42009-12-09 23:02:17 +00005684 // initializer to reflect that choice.
John Wiegley429bb272011-04-08 18:41:53 +00005685 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
Richard Smith82f145d2013-05-04 06:44:46 +00005686 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
5687 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005688 CurInit = S.FixOverloadedFunctionReference(CurInit,
John McCall6bb80172010-03-30 21:47:33 +00005689 Step->Function.FoundDecl,
John McCall9aa472c2010-03-19 07:35:19 +00005690 Step->Function.Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00005691 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005692
Douglas Gregor20093b42009-12-09 23:02:17 +00005693 case SK_CastDerivedToBaseRValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005694 case SK_CastDerivedToBaseXValue:
Douglas Gregor20093b42009-12-09 23:02:17 +00005695 case SK_CastDerivedToBaseLValue: {
5696 // We have a derived-to-base cast that produces either an rvalue or an
5697 // lvalue. Perform that cast.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005698
John McCallf871d0c2010-08-07 06:22:56 +00005699 CXXCastPath BasePath;
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005700
Douglas Gregor20093b42009-12-09 23:02:17 +00005701 // Casts to inaccessible base classes are allowed with C-style casts.
5702 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
5703 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
John Wiegley429bb272011-04-08 18:41:53 +00005704 CurInit.get()->getLocStart(),
5705 CurInit.get()->getSourceRange(),
Anders Carlsson5cf86ba2010-04-24 19:06:50 +00005706 &BasePath, IgnoreBaseAccess))
John McCallf312b1e2010-08-26 23:41:50 +00005707 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005708
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005709 if (S.BasePathInvolvesVirtualBase(BasePath)) {
5710 QualType T = SourceType;
5711 if (const PointerType *Pointer = T->getAs<PointerType>())
5712 T = Pointer->getPointeeType();
5713 if (const RecordType *RecordTy = T->getAs<RecordType>())
John Wiegley429bb272011-04-08 18:41:53 +00005714 S.MarkVTableUsed(CurInit.get()->getLocStart(),
Douglas Gregor6fb745b2010-05-13 16:44:06 +00005715 cast<CXXRecordDecl>(RecordTy->getDecl()));
5716 }
5717
John McCall5baba9d2010-08-25 10:28:54 +00005718 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005719 Step->Kind == SK_CastDerivedToBaseLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005720 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005721 (Step->Kind == SK_CastDerivedToBaseXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005722 VK_XValue :
5723 VK_RValue);
John McCallf871d0c2010-08-07 06:22:56 +00005724 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5725 Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00005726 CK_DerivedToBase,
John McCall5baba9d2010-08-25 10:28:54 +00005727 CurInit.get(),
5728 &BasePath, VK));
Douglas Gregor20093b42009-12-09 23:02:17 +00005729 break;
5730 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005731
Douglas Gregor20093b42009-12-09 23:02:17 +00005732 case SK_BindReference:
John McCall993f43f2013-05-06 21:39:12 +00005733 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
5734 if (CurInit.get()->refersToBitField()) {
5735 // We don't necessarily have an unambiguous source bit-field.
5736 FieldDecl *BitField = CurInit.get()->getSourceBitField();
Douglas Gregor20093b42009-12-09 23:02:17 +00005737 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
Douglas Gregord6542d82009-12-22 15:35:07 +00005738 << Entity.getType().isVolatileQualified()
John McCall993f43f2013-05-06 21:39:12 +00005739 << (BitField ? BitField->getDeclName() : DeclarationName())
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005740 << (BitField != nullptr)
John Wiegley429bb272011-04-08 18:41:53 +00005741 << CurInit.get()->getSourceRange();
John McCall993f43f2013-05-06 21:39:12 +00005742 if (BitField)
5743 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
5744
John McCallf312b1e2010-08-26 23:41:50 +00005745 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005746 }
Anders Carlssona6fe0bf2010-01-29 02:47:33 +00005747
John Wiegley429bb272011-04-08 18:41:53 +00005748 if (CurInit.get()->refersToVectorElement()) {
John McCall41593e32010-02-02 19:02:38 +00005749 // References cannot bind to vector elements.
Anders Carlsson09380262010-01-31 17:18:49 +00005750 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5751 << Entity.getType().isVolatileQualified()
John Wiegley429bb272011-04-08 18:41:53 +00005752 << CurInit.get()->getSourceRange();
Douglas Gregora41a8c52010-04-22 00:20:18 +00005753 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00005754 return ExprError();
Anders Carlsson09380262010-01-31 17:18:49 +00005755 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005756
Douglas Gregor20093b42009-12-09 23:02:17 +00005757 // Reference binding does not have any corresponding ASTs.
5758
5759 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005760 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005761 return ExprError();
Anders Carlsson3aba0932010-01-31 18:34:51 +00005762
Richard Smithd6b69872013-06-15 00:30:29 +00005763 // Even though we didn't materialize a temporary, the binding may still
5764 // extend the lifetime of a temporary. This happens if we bind a reference
5765 // to the result of a cast to reference type.
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005766 if (const InitializedEntity *ExtendingEntity =
5767 getEntityForTemporaryLifetimeExtension(&Entity))
5768 if (performReferenceExtension(CurInit.get(), ExtendingEntity))
5769 warnOnLifetimeExtension(S, Entity, CurInit.get(),
5770 /*IsInitializerList=*/false,
5771 ExtendingEntity->getDecl());
Richard Smithd6b69872013-06-15 00:30:29 +00005772
Douglas Gregor20093b42009-12-09 23:02:17 +00005773 break;
Anders Carlsson3aba0932010-01-31 18:34:51 +00005774
Richard Smith211c8dd2013-06-05 00:46:14 +00005775 case SK_BindReferenceToTemporary: {
Jordan Rose1fd1e282013-04-11 00:58:58 +00005776 // Make sure the "temporary" is actually an rvalue.
5777 assert(CurInit.get()->isRValue() && "not a temporary");
5778
Douglas Gregor20093b42009-12-09 23:02:17 +00005779 // Check exception specifications
John Wiegley429bb272011-04-08 18:41:53 +00005780 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
John McCallf312b1e2010-08-26 23:41:50 +00005781 return ExprError();
Douglas Gregor20093b42009-12-09 23:02:17 +00005782
Douglas Gregor03e80032011-06-21 17:03:29 +00005783 // Materialize the temporary into memory.
Richard Smith8a07cd32013-06-12 20:42:33 +00005784 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
Richard Smith211c8dd2013-06-05 00:46:14 +00005785 Entity.getType().getNonReferenceType(), CurInit.get(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005786 Entity.getType()->isLValueReferenceType());
5787
5788 // Maybe lifetime-extend the temporary's subobjects to match the
5789 // entity's lifetime.
5790 if (const InitializedEntity *ExtendingEntity =
5791 getEntityForTemporaryLifetimeExtension(&Entity))
5792 if (performReferenceExtension(MTE, ExtendingEntity))
5793 warnOnLifetimeExtension(S, Entity, CurInit.get(), /*IsInitializerList=*/false,
5794 ExtendingEntity->getDecl());
Douglas Gregord7b23162011-06-22 16:12:01 +00005795
5796 // If we're binding to an Objective-C object that has lifetime, we
Richard Smith8a07cd32013-06-12 20:42:33 +00005797 // need cleanups. Likewise if we're extending this temporary to automatic
5798 // storage duration -- we need to register its cleanup during the
5799 // full-expression's cleanups.
5800 if ((S.getLangOpts().ObjCAutoRefCount &&
5801 MTE->getType()->isObjCLifetimeType()) ||
5802 (MTE->getStorageDuration() == SD_Automatic &&
5803 MTE->getType().isDestructedType()))
Douglas Gregord7b23162011-06-22 16:12:01 +00005804 S.ExprNeedsCleanups = true;
Richard Smith8a07cd32013-06-12 20:42:33 +00005805
5806 CurInit = S.Owned(MTE);
Douglas Gregor20093b42009-12-09 23:02:17 +00005807 break;
Richard Smith211c8dd2013-06-05 00:46:14 +00005808 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005809
Douglas Gregor523d46a2010-04-18 07:40:54 +00005810 case SK_ExtraneousCopyToTemporary:
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005811 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
Douglas Gregor523d46a2010-04-18 07:40:54 +00005812 /*IsExtraneousCopy=*/true);
5813 break;
5814
Douglas Gregor20093b42009-12-09 23:02:17 +00005815 case SK_UserConversion: {
5816 // We have a user-defined conversion that invokes either a constructor
5817 // or a conversion function.
John McCalldaa8e4e2010-11-15 09:13:47 +00005818 CastKind CastKind;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005819 bool IsCopy = false;
John McCall9aa472c2010-03-19 07:35:19 +00005820 FunctionDecl *Fn = Step->Function.Function;
5821 DeclAccessPair FoundFn = Step->Function.FoundDecl;
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005822 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005823 bool CreatedObject = false;
John McCallb13b7372010-02-01 03:16:54 +00005824 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
Douglas Gregor20093b42009-12-09 23:02:17 +00005825 // Build a call to the selected constructor.
Benjamin Kramer4e28d9e2012-08-23 22:51:59 +00005826 SmallVector<Expr*, 8> ConstructorArgs;
John Wiegley429bb272011-04-08 18:41:53 +00005827 SourceLocation Loc = CurInit.get()->getLocStart();
Douglas Gregor20093b42009-12-09 23:02:17 +00005828 CurInit.release(); // Ownership transferred into MultiExprArg, below.
John McCallb13b7372010-02-01 03:16:54 +00005829
Douglas Gregor20093b42009-12-09 23:02:17 +00005830 // Determine the arguments required to actually perform the constructor
5831 // call.
John Wiegley429bb272011-04-08 18:41:53 +00005832 Expr *Arg = CurInit.get();
Douglas Gregor20093b42009-12-09 23:02:17 +00005833 if (S.CompleteConstructorCall(Constructor,
John Wiegley429bb272011-04-08 18:41:53 +00005834 MultiExprArg(&Arg, 1),
Douglas Gregor20093b42009-12-09 23:02:17 +00005835 Loc, ConstructorArgs))
John McCallf312b1e2010-08-26 23:41:50 +00005836 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005837
Richard Smithf2e4dfc2012-02-11 19:22:50 +00005838 // Build an expression that constructs a temporary.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005839 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005840 ConstructorArgs,
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005841 HadMultipleCandidates,
Richard Smithc83c2302012-12-19 01:39:02 +00005842 /*ListInit*/ false,
John McCall7a1fad32010-08-24 07:32:53 +00005843 /*ZeroInit*/ false,
Chandler Carruth428edaf2010-10-25 08:47:36 +00005844 CXXConstructExpr::CK_Complete,
5845 SourceRange());
Douglas Gregor20093b42009-12-09 23:02:17 +00005846 if (CurInit.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005847 return ExprError();
John McCallb13b7372010-02-01 03:16:54 +00005848
Anders Carlsson9a68a672010-04-21 18:47:17 +00005849 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
John McCall9aa472c2010-03-19 07:35:19 +00005850 FoundFn.getAccess());
Richard Smith82f145d2013-05-04 06:44:46 +00005851 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5852 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005853
John McCall2de56d12010-08-25 11:45:40 +00005854 CastKind = CK_ConstructorConversion;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00005855 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5856 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5857 S.IsDerivedFrom(SourceType, Class))
5858 IsCopy = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005859
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005860 CreatedObject = true;
Douglas Gregor20093b42009-12-09 23:02:17 +00005861 } else {
5862 // Build a call to the conversion function.
John McCallb13b7372010-02-01 03:16:54 +00005863 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005864 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
John McCall9aa472c2010-03-19 07:35:19 +00005865 FoundFn);
Richard Smith82f145d2013-05-04 06:44:46 +00005866 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5867 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005868
5869 // FIXME: Should we move this initialization into a separate
Douglas Gregor20093b42009-12-09 23:02:17 +00005870 // derived-to-base conversion? I believe the answer is "no", because
5871 // we don't want to turn off access control here for c-style casts.
John Wiegley429bb272011-04-08 18:41:53 +00005872 ExprResult CurInitExprRes =
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005873 S.PerformObjectArgumentInitialization(CurInit.take(),
5874 /*Qualifier=*/nullptr,
John Wiegley429bb272011-04-08 18:41:53 +00005875 FoundFn, Conversion);
5876 if(CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005877 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005878 CurInit = CurInitExprRes;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005879
Douglas Gregor20093b42009-12-09 23:02:17 +00005880 // Build the actual call to the conversion function.
Abramo Bagnara7cc58b42011-10-05 07:56:41 +00005881 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5882 HadMultipleCandidates);
Douglas Gregor20093b42009-12-09 23:02:17 +00005883 if (CurInit.isInvalid() || !CurInit.get())
John McCallf312b1e2010-08-26 23:41:50 +00005884 return ExprError();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005885
John McCall2de56d12010-08-25 11:45:40 +00005886 CastKind = CK_UserDefinedConversion;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005887
Stephen Hines651f13c2014-04-23 16:59:28 -07005888 CreatedObject = Conversion->getReturnType()->isRecordType();
Douglas Gregor20093b42009-12-09 23:02:17 +00005889 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005890
Sebastian Redl3b802322011-07-14 19:07:55 +00005891 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
Abramo Bagnara960809e2011-11-16 22:46:05 +00005892 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
5893
5894 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
John Wiegley429bb272011-04-08 18:41:53 +00005895 QualType T = CurInit.get()->getType();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005896 if (const RecordType *Record = T->getAs<RecordType>()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005897 CXXDestructorDecl *Destructor
Douglas Gregordb89f282010-07-01 22:47:18 +00005898 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
John Wiegley429bb272011-04-08 18:41:53 +00005899 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005900 S.PDiag(diag::err_access_dtor_temp) << T);
Eli Friedman5f2987c2012-02-02 03:46:19 +00005901 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
Richard Smith82f145d2013-05-04 06:44:46 +00005902 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
5903 return ExprError();
Douglas Gregor4154e0b2010-04-24 23:45:46 +00005904 }
5905 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005906
John McCallf871d0c2010-08-07 06:22:56 +00005907 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
John Wiegley429bb272011-04-08 18:41:53 +00005908 CurInit.get()->getType(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005909 CastKind, CurInit.get(),
5910 nullptr,
Eli Friedman104be6f2011-09-27 01:11:35 +00005911 CurInit.get()->getValueKind()));
Abramo Bagnara960809e2011-11-16 22:46:05 +00005912 if (MaybeBindToTemp)
5913 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
Douglas Gregor2f599792010-04-02 18:24:57 +00005914 if (RequiresCopy)
Douglas Gregor523d46a2010-04-18 07:40:54 +00005915 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005916 CurInit, /*IsExtraneousCopy=*/false);
Douglas Gregor20093b42009-12-09 23:02:17 +00005917 break;
5918 }
Sebastian Redl906082e2010-07-20 04:20:21 +00005919
Douglas Gregor20093b42009-12-09 23:02:17 +00005920 case SK_QualificationConversionLValue:
Sebastian Redl906082e2010-07-20 04:20:21 +00005921 case SK_QualificationConversionXValue:
5922 case SK_QualificationConversionRValue: {
Douglas Gregor20093b42009-12-09 23:02:17 +00005923 // Perform a qualification conversion; these can never go wrong.
John McCall5baba9d2010-08-25 10:28:54 +00005924 ExprValueKind VK =
Sebastian Redl906082e2010-07-20 04:20:21 +00005925 Step->Kind == SK_QualificationConversionLValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005926 VK_LValue :
Sebastian Redl906082e2010-07-20 04:20:21 +00005927 (Step->Kind == SK_QualificationConversionXValue ?
John McCall5baba9d2010-08-25 10:28:54 +00005928 VK_XValue :
5929 VK_RValue);
John Wiegley429bb272011-04-08 18:41:53 +00005930 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK);
Douglas Gregor20093b42009-12-09 23:02:17 +00005931 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00005932 }
5933
Jordan Rose1fd1e282013-04-11 00:58:58 +00005934 case SK_LValueToRValue: {
5935 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
5936 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
5937 CK_LValueToRValue,
5938 CurInit.take(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07005939 /*BasePath=*/nullptr,
Jordan Rose1fd1e282013-04-11 00:58:58 +00005940 VK_RValue));
5941 break;
5942 }
5943
Richard Smith13b228d2013-09-21 21:19:19 +00005944 case SK_ConversionSequence:
5945 case SK_ConversionSequenceNoNarrowing: {
5946 Sema::CheckedConversionKind CCK
John McCallf85e1932011-06-15 23:02:42 +00005947 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
5948 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
Richard Smithc8d7f582011-11-29 22:48:16 +00005949 : Kind.isExplicitCast()? Sema::CCK_OtherCast
John McCallf85e1932011-06-15 23:02:42 +00005950 : Sema::CCK_ImplicitConversion;
John Wiegley429bb272011-04-08 18:41:53 +00005951 ExprResult CurInitExprRes =
5952 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
John McCallf85e1932011-06-15 23:02:42 +00005953 getAssignmentAction(Entity), CCK);
John Wiegley429bb272011-04-08 18:41:53 +00005954 if (CurInitExprRes.isInvalid())
John McCallf312b1e2010-08-26 23:41:50 +00005955 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00005956 CurInit = CurInitExprRes;
Richard Smith13b228d2013-09-21 21:19:19 +00005957
5958 if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
5959 S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
5960 DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
5961 CurInit.get());
Douglas Gregor20093b42009-12-09 23:02:17 +00005962 break;
Douglas Gregorf0e43e52010-04-16 19:30:02 +00005963 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00005964
Douglas Gregord87b61f2009-12-10 17:56:55 +00005965 case SK_ListInitialization: {
John Wiegley429bb272011-04-08 18:41:53 +00005966 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
Richard Smith7c3e6152013-06-12 22:31:48 +00005967 // If we're not initializing the top-level entity, we need to create an
5968 // InitializeTemporary entity for our target type.
5969 QualType Ty = Step->Type;
5970 bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005971 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
Richard Smith802e2262013-02-02 01:13:06 +00005972 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
5973 InitListChecker PerformInitList(S, InitEntity,
Richard Smith40cba902013-06-06 11:41:05 +00005974 InitList, Ty, /*VerifyOnly=*/false);
Sebastian Redl14b0c192011-09-24 17:48:00 +00005975 if (PerformInitList.HadError())
John McCallf312b1e2010-08-26 23:41:50 +00005976 return ExprError();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005977
Richard Smith7c3e6152013-06-12 22:31:48 +00005978 // Hack: We must update *ResultType if available in order to set the
5979 // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
5980 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
5981 if (ResultType &&
5982 ResultType->getNonReferenceType()->isIncompleteArrayType()) {
Sebastian Redl13dc8f92011-11-27 16:50:07 +00005983 if ((*ResultType)->isRValueReferenceType())
5984 Ty = S.Context.getRValueReferenceType(Ty);
5985 else if ((*ResultType)->isLValueReferenceType())
5986 Ty = S.Context.getLValueReferenceType(Ty,
5987 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
5988 *ResultType = Ty;
5989 }
5990
5991 InitListExpr *StructuredInitList =
5992 PerformInitList.getFullyStructuredList();
Douglas Gregord87b61f2009-12-10 17:56:55 +00005993 CurInit.release();
Richard Smith802e2262013-02-02 01:13:06 +00005994 CurInit = shouldBindAsTemporary(InitEntity)
5995 ? S.MaybeBindToTemporary(StructuredInitList)
5996 : S.Owned(StructuredInitList);
Douglas Gregord87b61f2009-12-10 17:56:55 +00005997 break;
5998 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00005999
Sebastian Redl10f04a62011-12-22 14:44:04 +00006000 case SK_ListConstructorCall: {
Sebastian Redl168319c2012-02-12 16:37:24 +00006001 // When an initializer list is passed for a parameter of type "reference
6002 // to object", we don't get an EK_Temporary entity, but instead an
6003 // EK_Parameter entity with reference type.
Sebastian Redlbac5cf42012-02-19 12:27:56 +00006004 // FIXME: This is a hack. What we really should do is create a user
6005 // conversion step for this case, but this makes it considerably more
6006 // complicated. For now, this will do.
Sebastian Redl168319c2012-02-12 16:37:24 +00006007 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6008 Entity.getType().getNonReferenceType());
6009 bool UseTemporary = Entity.getType()->isReferenceType();
Richard Smithf4bb8d02012-07-05 08:39:21 +00006010 assert(Args.size() == 1 && "expected a single argument for list init");
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006011 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Richard Smith03544fc2012-04-19 06:58:00 +00006012 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6013 << InitList->getSourceRange();
Sebastian Redl10f04a62011-12-22 14:44:04 +00006014 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
Sebastian Redl168319c2012-02-12 16:37:24 +00006015 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6016 Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006017 Kind, Arg, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00006018 ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00006019 /*IsListInitialization*/ true,
6020 InitList->getLBraceLoc(),
6021 InitList->getRBraceLoc());
Sebastian Redl10f04a62011-12-22 14:44:04 +00006022 break;
6023 }
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006024
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006025 case SK_UnwrapInitList:
6026 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0));
6027 break;
6028
6029 case SK_RewrapInitList: {
6030 Expr *E = CurInit.take();
6031 InitListExpr *Syntactic = Step->WrappingSyntacticList;
6032 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00006033 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006034 ILE->setSyntacticForm(Syntactic);
6035 ILE->setType(E->getType());
6036 ILE->setValueKind(E->getValueKind());
6037 CurInit = S.Owned(ILE);
6038 break;
6039 }
6040
Sebastian Redlbac5cf42012-02-19 12:27:56 +00006041 case SK_ConstructorInitialization: {
6042 // When an initializer list is passed for a parameter of type "reference
6043 // to object", we don't get an EK_Temporary entity, but instead an
6044 // EK_Parameter entity with reference type.
6045 // FIXME: This is a hack. What we really should do is create a user
6046 // conversion step for this case, but this makes it considerably more
6047 // complicated. For now, this will do.
6048 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6049 Entity.getType().getNonReferenceType());
6050 bool UseTemporary = Entity.getType()->isReferenceType();
6051 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity
6052 : Entity,
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006053 Kind, Args, *Step,
Richard Smithc83c2302012-12-19 01:39:02 +00006054 ConstructorInitRequiresZeroInit,
Enea Zaffanella1245a542013-09-07 05:49:53 +00006055 /*IsListInitialization*/ false,
6056 /*LBraceLoc*/ SourceLocation(),
6057 /*RBraceLoc*/ SourceLocation());
Douglas Gregor51c56d62009-12-14 20:49:26 +00006058 break;
Sebastian Redlbac5cf42012-02-19 12:27:56 +00006059 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006060
Douglas Gregor71d17402009-12-15 00:01:57 +00006061 case SK_ZeroInitialization: {
Douglas Gregor16006c92009-12-16 18:50:27 +00006062 step_iterator NextStep = Step;
6063 ++NextStep;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006064 if (NextStep != StepEnd &&
Richard Smithf4bb8d02012-07-05 08:39:21 +00006065 (NextStep->Kind == SK_ConstructorInitialization ||
6066 NextStep->Kind == SK_ListConstructorCall)) {
Douglas Gregor16006c92009-12-16 18:50:27 +00006067 // The need for zero-initialization is recorded directly into
6068 // the call to the object's constructor within the next step.
6069 ConstructorInitRequiresZeroInit = true;
6070 } else if (Kind.getKind() == InitializationKind::IK_Value &&
David Blaikie4e4d0842012-03-11 07:00:24 +00006071 S.getLangOpts().CPlusPlus &&
Douglas Gregor16006c92009-12-16 18:50:27 +00006072 !Kind.isImplicitValueInit()) {
Douglas Gregorab6677e2010-09-08 00:15:04 +00006073 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6074 if (!TSInfo)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006075 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
Douglas Gregorab6677e2010-09-08 00:15:04 +00006076 Kind.getRange().getBegin());
6077
6078 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr(
6079 TSInfo->getType().getNonLValueExprType(S.Context),
6080 TSInfo,
Douglas Gregor71d17402009-12-15 00:01:57 +00006081 Kind.getRange().getEnd()));
Douglas Gregor16006c92009-12-16 18:50:27 +00006082 } else {
Douglas Gregor71d17402009-12-15 00:01:57 +00006083 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
Douglas Gregor16006c92009-12-16 18:50:27 +00006084 }
Douglas Gregor71d17402009-12-15 00:01:57 +00006085 break;
6086 }
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006087
6088 case SK_CAssignment: {
John Wiegley429bb272011-04-08 18:41:53 +00006089 QualType SourceType = CurInit.get()->getType();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006090 ExprResult Result = CurInit;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006091 Sema::AssignConvertType ConvTy =
Fariborz Jahanian01ad0482013-07-31 21:40:51 +00006092 S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6093 Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
John Wiegley429bb272011-04-08 18:41:53 +00006094 if (Result.isInvalid())
6095 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006096 CurInit = Result;
Douglas Gregoraa037312009-12-22 07:24:36 +00006097
6098 // If this is a call, allow conversion to a transparent union.
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006099 ExprResult CurInitExprRes = CurInit;
Douglas Gregoraa037312009-12-22 07:24:36 +00006100 if (ConvTy != Sema::Compatible &&
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006101 Entity.isParameterKind() &&
John Wiegley429bb272011-04-08 18:41:53 +00006102 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
Douglas Gregoraa037312009-12-22 07:24:36 +00006103 == Sema::Compatible)
6104 ConvTy = Sema::Compatible;
John Wiegley429bb272011-04-08 18:41:53 +00006105 if (CurInitExprRes.isInvalid())
6106 return ExprError();
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006107 CurInit = CurInitExprRes;
Douglas Gregoraa037312009-12-22 07:24:36 +00006108
Douglas Gregora41a8c52010-04-22 00:20:18 +00006109 bool Complained;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006110 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6111 Step->Type, SourceType,
John Wiegley429bb272011-04-08 18:41:53 +00006112 CurInit.get(),
Fariborz Jahanian3d672e42013-07-31 23:19:34 +00006113 getAssignmentAction(Entity, true),
Douglas Gregora41a8c52010-04-22 00:20:18 +00006114 &Complained)) {
6115 PrintInitLocationNote(S, Entity);
John McCallf312b1e2010-08-26 23:41:50 +00006116 return ExprError();
Douglas Gregora41a8c52010-04-22 00:20:18 +00006117 } else if (Complained)
6118 PrintInitLocationNote(S, Entity);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006119 break;
6120 }
Eli Friedmancfdc81a2009-12-19 08:11:05 +00006121
6122 case SK_StringInit: {
6123 QualType Ty = Step->Type;
John Wiegley429bb272011-04-08 18:41:53 +00006124 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
John McCallfef8b342011-02-21 07:57:55 +00006125 S.Context.getAsArrayType(Ty), S);
Eli Friedmancfdc81a2009-12-19 08:11:05 +00006126 break;
6127 }
Douglas Gregor569c3162010-08-07 11:51:51 +00006128
6129 case SK_ObjCObjectConversion:
John Wiegley429bb272011-04-08 18:41:53 +00006130 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
John McCall2de56d12010-08-25 11:45:40 +00006131 CK_ObjCObjectLValueCast,
Eli Friedmanc1c0dfb2011-09-27 21:58:52 +00006132 CurInit.get()->getValueKind());
Douglas Gregor569c3162010-08-07 11:51:51 +00006133 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006134
6135 case SK_ArrayInit:
6136 // Okay: we checked everything before creating this step. Note that
6137 // this is a GNU extension.
6138 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
John Wiegley429bb272011-04-08 18:41:53 +00006139 << Step->Type << CurInit.get()->getType()
6140 << CurInit.get()->getSourceRange();
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006141
6142 // If the destination type is an incomplete array type, update the
6143 // type accordingly.
6144 if (ResultType) {
6145 if (const IncompleteArrayType *IncompleteDest
6146 = S.Context.getAsIncompleteArrayType(Step->Type)) {
6147 if (const ConstantArrayType *ConstantSource
John Wiegley429bb272011-04-08 18:41:53 +00006148 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006149 *ResultType = S.Context.getConstantArrayType(
6150 IncompleteDest->getElementType(),
6151 ConstantSource->getSize(),
6152 ArrayType::Normal, 0);
6153 }
6154 }
6155 }
John McCallf85e1932011-06-15 23:02:42 +00006156 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006157
Richard Smith0f163e92012-02-15 22:38:09 +00006158 case SK_ParenthesizedArrayInit:
6159 // Okay: we checked everything before creating this step. Note that
6160 // this is a GNU extension.
6161 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6162 << CurInit.get()->getSourceRange();
6163 break;
6164
John McCallf85e1932011-06-15 23:02:42 +00006165 case SK_PassByIndirectCopyRestore:
6166 case SK_PassByIndirectRestore:
6167 checkIndirectCopyRestoreSource(S, CurInit.get());
6168 CurInit = S.Owned(new (S.Context)
6169 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type,
6170 Step->Kind == SK_PassByIndirectCopyRestore));
6171 break;
6172
6173 case SK_ProduceObjCObject:
6174 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
John McCall33e56f32011-09-10 06:18:15 +00006175 CK_ARCProduceObject,
Stephen Hines6bcf27b2014-05-29 04:14:42 -07006176 CurInit.take(), nullptr,
6177 VK_RValue));
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006178 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006179
6180 case SK_StdInitializerList: {
Richard Smith7c3e6152013-06-12 22:31:48 +00006181 S.Diag(CurInit.get()->getExprLoc(),
6182 diag::warn_cxx98_compat_initializer_list_init)
6183 << CurInit.get()->getSourceRange();
Sebastian Redl28357452012-03-05 19:35:43 +00006184
Richard Smith7c3e6152013-06-12 22:31:48 +00006185 // Materialize the temporary into memory.
6186 MaterializeTemporaryExpr *MTE = new (S.Context)
6187 MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
Stephen Hines6bcf27b2014-05-29 04:14:42 -07006188 /*BoundToLvalueReference=*/false);
6189
6190 // Maybe lifetime-extend the array temporary's subobjects to match the
6191 // entity's lifetime.
6192 if (const InitializedEntity *ExtendingEntity =
6193 getEntityForTemporaryLifetimeExtension(&Entity))
6194 if (performReferenceExtension(MTE, ExtendingEntity))
6195 warnOnLifetimeExtension(S, Entity, CurInit.get(),
6196 /*IsInitializerList=*/true,
6197 ExtendingEntity->getDecl());
Richard Smith7c3e6152013-06-12 22:31:48 +00006198
6199 // Wrap it in a construction of a std::initializer_list<T>.
6200 CurInit = S.Owned(
6201 new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE));
6202
6203 // Bind the result, in case the library has given initializer_list a
6204 // non-trivial destructor.
6205 if (shouldBindAsTemporary(Entity))
6206 CurInit = S.MaybeBindToTemporary(CurInit.take());
Sebastian Redl2b916b82012-01-17 22:49:42 +00006207 break;
6208 }
Richard Smith7c3e6152013-06-12 22:31:48 +00006209
Guy Benyei21f18c42013-02-07 10:55:47 +00006210 case SK_OCLSamplerInit: {
6211 assert(Step->Type->isSamplerT() &&
Stephen Hines651f13c2014-04-23 16:59:28 -07006212 "Sampler initialization on non-sampler type.");
Guy Benyei21f18c42013-02-07 10:55:47 +00006213
6214 QualType SourceType = CurInit.get()->getType();
Guy Benyei21f18c42013-02-07 10:55:47 +00006215
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006216 if (Entity.isParameterKind()) {
Guy Benyei21f18c42013-02-07 10:55:47 +00006217 if (!SourceType->isSamplerT())
6218 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6219 << SourceType;
Fariborz Jahanian2651b7a2013-07-31 18:21:45 +00006220 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
Guy Benyei21f18c42013-02-07 10:55:47 +00006221 llvm_unreachable("Invalid EntityKind!");
6222 }
6223
6224 break;
6225 }
Guy Benyeie6b9d802013-01-20 12:31:11 +00006226 case SK_OCLZeroEvent: {
6227 assert(Step->Type->isEventT() &&
Stephen Hines651f13c2014-04-23 16:59:28 -07006228 "Event initialization on non-event type.");
Guy Benyeie6b9d802013-01-20 12:31:11 +00006229
6230 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
6231 CK_ZeroToOCLEvent,
6232 CurInit.get()->getValueKind());
6233 break;
6234 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006235 }
6236 }
John McCall15d7d122010-11-11 03:21:53 +00006237
6238 // Diagnose non-fatal problems with the completed initialization.
6239 if (Entity.getKind() == InitializedEntity::EK_Member &&
6240 cast<FieldDecl>(Entity.getDecl())->isBitField())
6241 S.CheckBitFieldInitialization(Kind.getLocation(),
6242 cast<FieldDecl>(Entity.getDecl()),
6243 CurInit.get());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006244
Benjamin Kramer3fe198b2012-08-23 21:35:17 +00006245 return CurInit;
Douglas Gregor20093b42009-12-09 23:02:17 +00006246}
6247
Richard Smithd5bc8672012-12-08 02:01:17 +00006248/// Somewhere within T there is an uninitialized reference subobject.
6249/// Dig it out and diagnose it.
Benjamin Kramera574c892013-02-15 12:30:38 +00006250static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6251 QualType T) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006252 if (T->isReferenceType()) {
6253 S.Diag(Loc, diag::err_reference_without_init)
6254 << T.getNonReferenceType();
6255 return true;
6256 }
6257
6258 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6259 if (!RD || !RD->hasUninitializedReferenceMember())
6260 return false;
6261
Stephen Hines651f13c2014-04-23 16:59:28 -07006262 for (const auto *FI : RD->fields()) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006263 if (FI->isUnnamedBitfield())
6264 continue;
6265
6266 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6267 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6268 return true;
6269 }
6270 }
6271
Stephen Hines651f13c2014-04-23 16:59:28 -07006272 for (const auto &BI : RD->bases()) {
6273 if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006274 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6275 return true;
6276 }
6277 }
6278
6279 return false;
6280}
6281
6282
Douglas Gregor20093b42009-12-09 23:02:17 +00006283//===----------------------------------------------------------------------===//
6284// Diagnose initialization failures
6285//===----------------------------------------------------------------------===//
John McCall7cca8212013-03-19 07:04:25 +00006286
6287/// Emit notes associated with an initialization that failed due to a
6288/// "simple" conversion failure.
6289static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6290 Expr *op) {
6291 QualType destType = entity.getType();
6292 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6293 op->getType()->isObjCObjectPointerType()) {
6294
6295 // Emit a possible note about the conversion failing because the
6296 // operand is a message send with a related result type.
6297 S.EmitRelatedResultTypeNote(op);
6298
6299 // Emit a possible note about a return failing because we're
6300 // expecting a related result type.
6301 if (entity.getKind() == InitializedEntity::EK_Result)
6302 S.EmitRelatedResultTypeNoteForReturn(destType);
6303 }
6304}
6305
Bill Wendling2ca3db42013-11-22 00:01:44 +00006306static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6307 InitListExpr *InitList) {
6308 QualType DestType = Entity.getType();
6309
6310 QualType E;
6311 if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6312 QualType ArrayType = S.Context.getConstantArrayType(
6313 E.withConst(),
6314 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6315 InitList->getNumInits()),
6316 clang::ArrayType::Normal, 0);
6317 InitializedEntity HiddenArray =
6318 InitializedEntity::InitializeTemporary(ArrayType);
6319 return diagnoseListInit(S, HiddenArray, InitList);
6320 }
6321
6322 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6323 /*VerifyOnly=*/false);
6324 assert(DiagnoseInitList.HadError() &&
6325 "Inconsistent init list check result.");
6326}
6327
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006328bool InitializationSequence::Diagnose(Sema &S,
Douglas Gregor20093b42009-12-09 23:02:17 +00006329 const InitializedEntity &Entity,
6330 const InitializationKind &Kind,
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006331 ArrayRef<Expr *> Args) {
Sebastian Redld695d6b2011-06-05 13:59:05 +00006332 if (!Failed())
Douglas Gregor20093b42009-12-09 23:02:17 +00006333 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006334
Douglas Gregord6542d82009-12-22 15:35:07 +00006335 QualType DestType = Entity.getType();
Douglas Gregor20093b42009-12-09 23:02:17 +00006336 switch (Failure) {
6337 case FK_TooManyInitsForReference:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006338 // FIXME: Customize for the initialized entity?
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006339 if (Args.empty()) {
Richard Smithd5bc8672012-12-08 02:01:17 +00006340 // Dig out the reference subobject which is uninitialized and diagnose it.
6341 // If this is value-initialization, this could be nested some way within
6342 // the target type.
6343 assert(Kind.getKind() == InitializationKind::IK_Value ||
6344 DestType->isReferenceType());
6345 bool Diagnosed =
6346 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6347 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6348 (void)Diagnosed;
6349 } else // FIXME: diagnostic below could be better!
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006350 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006351 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
Douglas Gregor20093b42009-12-09 23:02:17 +00006352 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006353
Douglas Gregor20093b42009-12-09 23:02:17 +00006354 case FK_ArrayNeedsInitList:
Hans Wennborg0ff50742013-05-15 11:03:04 +00006355 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
Douglas Gregor20093b42009-12-09 23:02:17 +00006356 break;
Hans Wennborg0ff50742013-05-15 11:03:04 +00006357 case FK_ArrayNeedsInitListOrStringLiteral:
6358 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6359 break;
6360 case FK_ArrayNeedsInitListOrWideStringLiteral:
6361 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6362 break;
6363 case FK_NarrowStringIntoWideCharArray:
6364 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6365 break;
6366 case FK_WideStringIntoCharArray:
6367 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6368 break;
6369 case FK_IncompatWideStringIntoWideChar:
6370 S.Diag(Kind.getLocation(),
6371 diag::err_array_init_incompat_wide_string_into_wchar);
6372 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006373 case FK_ArrayTypeMismatch:
6374 case FK_NonConstantArrayInit:
Bill Wendling2ca3db42013-11-22 00:01:44 +00006375 S.Diag(Kind.getLocation(),
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006376 (Failure == FK_ArrayTypeMismatch
6377 ? diag::err_array_init_different_type
6378 : diag::err_array_init_non_constant_array))
6379 << DestType.getNonReferenceType()
6380 << Args[0]->getType()
6381 << Args[0]->getSourceRange();
6382 break;
6383
John McCall73076432012-01-05 00:13:19 +00006384 case FK_VariableLengthArrayHasInitializer:
6385 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6386 << Args[0]->getSourceRange();
6387 break;
6388
John McCall6bb80172010-03-30 21:47:33 +00006389 case FK_AddressOfOverloadFailed: {
6390 DeclAccessPair Found;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006391 S.ResolveAddressOfOverloadedFunction(Args[0],
Douglas Gregor20093b42009-12-09 23:02:17 +00006392 DestType.getNonReferenceType(),
John McCall6bb80172010-03-30 21:47:33 +00006393 true,
6394 Found);
Douglas Gregor20093b42009-12-09 23:02:17 +00006395 break;
John McCall6bb80172010-03-30 21:47:33 +00006396 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006397
Douglas Gregor20093b42009-12-09 23:02:17 +00006398 case FK_ReferenceInitOverloadFailed:
Douglas Gregor4a520a22009-12-14 17:27:33 +00006399 case FK_UserConversionOverloadFailed:
Douglas Gregor20093b42009-12-09 23:02:17 +00006400 switch (FailedOverloadResult) {
6401 case OR_Ambiguous:
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006402 if (Failure == FK_UserConversionOverloadFailed)
6403 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6404 << Args[0]->getType() << DestType
6405 << Args[0]->getSourceRange();
6406 else
6407 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6408 << DestType << Args[0]->getType()
6409 << Args[0]->getSourceRange();
6410
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006411 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006412 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006413
Douglas Gregor20093b42009-12-09 23:02:17 +00006414 case OR_No_Viable_Function:
Larisse Voufo288f76a2013-06-27 03:36:30 +00006415 if (!S.RequireCompleteType(Kind.getLocation(),
Larisse Voufo7419d012013-06-27 01:50:25 +00006416 DestType.getNonReferenceType(),
6417 diag::err_typecheck_nonviable_condition_incomplete,
6418 Args[0]->getType(), Args[0]->getSourceRange()))
6419 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6420 << Args[0]->getType() << Args[0]->getSourceRange()
6421 << DestType.getNonReferenceType();
6422
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006423 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor20093b42009-12-09 23:02:17 +00006424 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006425
Douglas Gregor20093b42009-12-09 23:02:17 +00006426 case OR_Deleted: {
6427 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6428 << Args[0]->getType() << DestType.getNonReferenceType()
6429 << Args[0]->getSourceRange();
6430 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006431 OverloadingResult Ovl
Douglas Gregor8fcc5162010-09-12 08:07:23 +00006432 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6433 true);
Douglas Gregor20093b42009-12-09 23:02:17 +00006434 if (Ovl == OR_Deleted) {
Richard Smith6c4c36c2012-03-30 20:53:28 +00006435 S.NoteDeletedFunction(Best->Function);
Douglas Gregor20093b42009-12-09 23:02:17 +00006436 } else {
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006437 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregor20093b42009-12-09 23:02:17 +00006438 }
6439 break;
6440 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006441
Douglas Gregor20093b42009-12-09 23:02:17 +00006442 case OR_Success:
Jeffrey Yasskin9f61aa92009-12-12 05:05:38 +00006443 llvm_unreachable("Conversion did not fail!");
Douglas Gregor20093b42009-12-09 23:02:17 +00006444 }
6445 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006446
Douglas Gregor20093b42009-12-09 23:02:17 +00006447 case FK_NonConstLValueReferenceBindingToTemporary:
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006448 if (isa<InitListExpr>(Args[0])) {
6449 S.Diag(Kind.getLocation(),
6450 diag::err_lvalue_reference_bind_to_initlist)
6451 << DestType.getNonReferenceType().isVolatileQualified()
6452 << DestType.getNonReferenceType()
6453 << Args[0]->getSourceRange();
6454 break;
6455 }
6456 // Intentional fallthrough
6457
Douglas Gregor20093b42009-12-09 23:02:17 +00006458 case FK_NonConstLValueReferenceBindingToUnrelated:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006459 S.Diag(Kind.getLocation(),
Douglas Gregor20093b42009-12-09 23:02:17 +00006460 Failure == FK_NonConstLValueReferenceBindingToTemporary
6461 ? diag::err_lvalue_reference_bind_to_temporary
6462 : diag::err_lvalue_reference_bind_to_unrelated)
Douglas Gregoref06e242010-01-29 19:39:15 +00006463 << DestType.getNonReferenceType().isVolatileQualified()
Douglas Gregor20093b42009-12-09 23:02:17 +00006464 << DestType.getNonReferenceType()
6465 << Args[0]->getType()
6466 << Args[0]->getSourceRange();
6467 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006468
Douglas Gregor20093b42009-12-09 23:02:17 +00006469 case FK_RValueReferenceBindingToLValue:
6470 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
Douglas Gregorfb5d7ef2011-01-21 01:04:33 +00006471 << DestType.getNonReferenceType() << Args[0]->getType()
Douglas Gregor20093b42009-12-09 23:02:17 +00006472 << Args[0]->getSourceRange();
6473 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006474
Douglas Gregor20093b42009-12-09 23:02:17 +00006475 case FK_ReferenceInitDropsQualifiers:
6476 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
6477 << DestType.getNonReferenceType()
6478 << Args[0]->getType()
6479 << Args[0]->getSourceRange();
6480 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006481
Douglas Gregor20093b42009-12-09 23:02:17 +00006482 case FK_ReferenceInitFailed:
6483 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
6484 << DestType.getNonReferenceType()
John McCall7eb0a9e2010-11-24 05:12:34 +00006485 << Args[0]->isLValue()
Douglas Gregor20093b42009-12-09 23:02:17 +00006486 << Args[0]->getType()
6487 << Args[0]->getSourceRange();
John McCall7cca8212013-03-19 07:04:25 +00006488 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregor20093b42009-12-09 23:02:17 +00006489 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006490
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006491 case FK_ConversionFailed: {
6492 QualType FromType = Args[0]->getType();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006493 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006494 << (int)Entity.getKind()
Douglas Gregor20093b42009-12-09 23:02:17 +00006495 << DestType
John McCall7eb0a9e2010-11-24 05:12:34 +00006496 << Args[0]->isLValue()
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006497 << FromType
Douglas Gregor20093b42009-12-09 23:02:17 +00006498 << Args[0]->getSourceRange();
Richard Trieu6efd4c52011-11-23 22:32:32 +00006499 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
6500 S.Diag(Kind.getLocation(), PDiag);
John McCall7cca8212013-03-19 07:04:25 +00006501 emitBadConversionNotes(S, Entity, Args[0]);
Douglas Gregord87b61f2009-12-10 17:56:55 +00006502 break;
Douglas Gregor1be8eec2011-02-19 21:32:49 +00006503 }
John Wiegley429bb272011-04-08 18:41:53 +00006504
6505 case FK_ConversionFromPropertyFailed:
6506 // No-op. This error has already been reported.
6507 break;
6508
Douglas Gregord87b61f2009-12-10 17:56:55 +00006509 case FK_TooManyInitsForScalar: {
Douglas Gregor99a2e602009-12-16 01:38:02 +00006510 SourceRange R;
6511
6512 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
Douglas Gregor19311e72010-09-08 21:40:08 +00006513 R = SourceRange(InitList->getInit(0)->getLocEnd(),
Douglas Gregor99a2e602009-12-16 01:38:02 +00006514 InitList->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006515 else
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006516 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
Douglas Gregord87b61f2009-12-10 17:56:55 +00006517
Stephen Hines6bcf27b2014-05-29 04:14:42 -07006518 R.setBegin(S.getLocForEndOfToken(R.getBegin()));
Douglas Gregor19311e72010-09-08 21:40:08 +00006519 if (Kind.isCStyleOrFunctionalCast())
6520 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
6521 << R;
6522 else
6523 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
6524 << /*scalar=*/2 << R;
Douglas Gregord87b61f2009-12-10 17:56:55 +00006525 break;
6526 }
6527
6528 case FK_ReferenceBindingToInitList:
6529 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
6530 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
6531 break;
6532
6533 case FK_InitListBadDestinationType:
6534 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
6535 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
6536 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006537
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006538 case FK_ListConstructorOverloadFailed:
Douglas Gregor51c56d62009-12-14 20:49:26 +00006539 case FK_ConstructorOverloadFailed: {
6540 SourceRange ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006541 if (Args.size())
6542 ArgsRange = SourceRange(Args.front()->getLocStart(),
6543 Args.back()->getLocEnd());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006544
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006545 if (Failure == FK_ListConstructorOverloadFailed) {
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006546 assert(Args.size() == 1 && "List construction from other than 1 argument.");
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006547 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006548 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
Sebastian Redlcf15cef2011-12-22 18:58:38 +00006549 }
6550
Douglas Gregor51c56d62009-12-14 20:49:26 +00006551 // FIXME: Using "DestType" for the entity we're printing is probably
6552 // bad.
6553 switch (FailedOverloadResult) {
6554 case OR_Ambiguous:
6555 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
6556 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006557 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006558 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006559
Douglas Gregor51c56d62009-12-14 20:49:26 +00006560 case OR_No_Viable_Function:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006561 if (Kind.getKind() == InitializationKind::IK_Default &&
6562 (Entity.getKind() == InitializedEntity::EK_Base ||
6563 Entity.getKind() == InitializedEntity::EK_Member) &&
6564 isa<CXXConstructorDecl>(S.CurContext)) {
6565 // This is implicit default initialization of a member or
6566 // base within a constructor. If no viable function was
6567 // found, notify the user that she needs to explicitly
6568 // initialize this base/member.
6569 CXXConstructorDecl *Constructor
6570 = cast<CXXConstructorDecl>(S.CurContext);
6571 if (Entity.getKind() == InitializedEntity::EK_Base) {
6572 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006573 << (Constructor->getInheritedConstructor() ? 2 :
6574 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006575 << S.Context.getTypeDeclType(Constructor->getParent())
6576 << /*base=*/0
6577 << Entity.getType();
6578
6579 RecordDecl *BaseDecl
6580 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
6581 ->getDecl();
6582 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
6583 << S.Context.getTagDeclType(BaseDecl);
6584 } else {
6585 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006586 << (Constructor->getInheritedConstructor() ? 2 :
6587 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006588 << S.Context.getTypeDeclType(Constructor->getParent())
6589 << /*member=*/1
6590 << Entity.getName();
6591 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
6592
6593 if (const RecordType *Record
6594 = Entity.getType()->getAs<RecordType>())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006595 S.Diag(Record->getDecl()->getLocation(),
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006596 diag::note_previous_decl)
6597 << S.Context.getTagDeclType(Record->getDecl());
6598 }
6599 break;
6600 }
6601
Douglas Gregor51c56d62009-12-14 20:49:26 +00006602 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
6603 << DestType << ArgsRange;
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00006604 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006605 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006606
Douglas Gregor51c56d62009-12-14 20:49:26 +00006607 case OR_Deleted: {
Douglas Gregor51c56d62009-12-14 20:49:26 +00006608 OverloadCandidateSet::iterator Best;
John McCall120d63c2010-08-24 20:38:10 +00006609 OverloadingResult Ovl
6610 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Douglas Gregore4e68d42012-02-15 19:33:52 +00006611 if (Ovl != OR_Deleted) {
6612 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6613 << true << DestType << ArgsRange;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006614 llvm_unreachable("Inconsistent overload resolution?");
Douglas Gregore4e68d42012-02-15 19:33:52 +00006615 break;
Douglas Gregor51c56d62009-12-14 20:49:26 +00006616 }
Douglas Gregore4e68d42012-02-15 19:33:52 +00006617
6618 // If this is a defaulted or implicitly-declared function, then
6619 // it was implicitly deleted. Make it clear that the deletion was
6620 // implicit.
Richard Smith6c4c36c2012-03-30 20:53:28 +00006621 if (S.isImplicitlyDeleted(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006622 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
Richard Smith6c4c36c2012-03-30 20:53:28 +00006623 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
Douglas Gregore4e68d42012-02-15 19:33:52 +00006624 << DestType << ArgsRange;
Richard Smith6c4c36c2012-03-30 20:53:28 +00006625 else
6626 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6627 << true << DestType << ArgsRange;
6628
6629 S.NoteDeletedFunction(Best->Function);
Douglas Gregor51c56d62009-12-14 20:49:26 +00006630 break;
6631 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006632
Douglas Gregor51c56d62009-12-14 20:49:26 +00006633 case OR_Success:
6634 llvm_unreachable("Conversion did not fail!");
Douglas Gregor51c56d62009-12-14 20:49:26 +00006635 }
Douglas Gregor51c56d62009-12-14 20:49:26 +00006636 }
David Blaikie9fdefb32012-01-17 08:24:58 +00006637 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006638
Douglas Gregor99a2e602009-12-16 01:38:02 +00006639 case FK_DefaultInitOfConst:
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006640 if (Entity.getKind() == InitializedEntity::EK_Member &&
6641 isa<CXXConstructorDecl>(S.CurContext)) {
6642 // This is implicit default-initialization of a const member in
6643 // a constructor. Complain that it needs to be explicitly
6644 // initialized.
6645 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
6646 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
Richard Smith07b0fdc2013-03-18 21:12:30 +00006647 << (Constructor->getInheritedConstructor() ? 2 :
6648 Constructor->isImplicit() ? 1 : 0)
Douglas Gregor9db7dbb2010-01-31 09:12:51 +00006649 << S.Context.getTypeDeclType(Constructor->getParent())
6650 << /*const=*/1
6651 << Entity.getName();
6652 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
6653 << Entity.getName();
6654 } else {
6655 S.Diag(Kind.getLocation(), diag::err_default_init_const)
6656 << DestType << (bool)DestType->getAs<RecordType>();
6657 }
Douglas Gregor99a2e602009-12-16 01:38:02 +00006658 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006659
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006660 case FK_Incomplete:
Douglas Gregor69a30b82012-04-10 20:43:46 +00006661 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006662 diag::err_init_incomplete_type);
6663 break;
6664
Sebastian Redl14b0c192011-09-24 17:48:00 +00006665 case FK_ListInitializationFailed: {
6666 // Run the init list checker again to emit diagnostics.
Bill Wendling2ca3db42013-11-22 00:01:44 +00006667 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6668 diagnoseListInit(S, Entity, InitList);
Sebastian Redl14b0c192011-09-24 17:48:00 +00006669 break;
6670 }
John McCall5acb0c92011-10-17 18:40:02 +00006671
6672 case FK_PlaceholderType: {
6673 // FIXME: Already diagnosed!
6674 break;
6675 }
Sebastian Redl2b916b82012-01-17 22:49:42 +00006676
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006677 case FK_ExplicitConstructor: {
6678 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
6679 << Args[0]->getSourceRange();
6680 OverloadCandidateSet::iterator Best;
6681 OverloadingResult Ovl
6682 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
Matt Beaumont-Gaye7d0bbf2012-04-02 19:05:35 +00006683 (void)Ovl;
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006684 assert(Ovl == OR_Success && "Inconsistent overload resolution");
6685 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
6686 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
6687 break;
6688 }
Douglas Gregor20093b42009-12-09 23:02:17 +00006689 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006690
Douglas Gregora41a8c52010-04-22 00:20:18 +00006691 PrintInitLocationNote(S, Entity);
Douglas Gregor20093b42009-12-09 23:02:17 +00006692 return true;
6693}
Douglas Gregor18ef5e22009-12-18 05:02:21 +00006694
Chris Lattner5f9e2722011-07-23 10:55:15 +00006695void InitializationSequence::dump(raw_ostream &OS) const {
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006696 switch (SequenceKind) {
6697 case FailedSequence: {
6698 OS << "Failed sequence: ";
6699 switch (Failure) {
6700 case FK_TooManyInitsForReference:
6701 OS << "too many initializers for reference";
6702 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006703
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006704 case FK_ArrayNeedsInitList:
6705 OS << "array requires initializer list";
6706 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006707
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006708 case FK_ArrayNeedsInitListOrStringLiteral:
6709 OS << "array requires initializer list or string literal";
6710 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006711
Hans Wennborg0ff50742013-05-15 11:03:04 +00006712 case FK_ArrayNeedsInitListOrWideStringLiteral:
6713 OS << "array requires initializer list or wide string literal";
6714 break;
6715
6716 case FK_NarrowStringIntoWideCharArray:
6717 OS << "narrow string into wide char array";
6718 break;
6719
6720 case FK_WideStringIntoCharArray:
6721 OS << "wide string into char array";
6722 break;
6723
6724 case FK_IncompatWideStringIntoWideChar:
6725 OS << "incompatible wide string into wide char array";
6726 break;
6727
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006728 case FK_ArrayTypeMismatch:
6729 OS << "array type mismatch";
6730 break;
6731
6732 case FK_NonConstantArrayInit:
6733 OS << "non-constant array initializer";
6734 break;
6735
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006736 case FK_AddressOfOverloadFailed:
6737 OS << "address of overloaded function failed";
6738 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006739
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006740 case FK_ReferenceInitOverloadFailed:
6741 OS << "overload resolution for reference initialization failed";
6742 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006743
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006744 case FK_NonConstLValueReferenceBindingToTemporary:
6745 OS << "non-const lvalue reference bound to temporary";
6746 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006747
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006748 case FK_NonConstLValueReferenceBindingToUnrelated:
6749 OS << "non-const lvalue reference bound to unrelated type";
6750 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006751
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006752 case FK_RValueReferenceBindingToLValue:
6753 OS << "rvalue reference bound to an lvalue";
6754 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006755
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006756 case FK_ReferenceInitDropsQualifiers:
6757 OS << "reference initialization drops qualifiers";
6758 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006759
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006760 case FK_ReferenceInitFailed:
6761 OS << "reference initialization failed";
6762 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006763
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006764 case FK_ConversionFailed:
6765 OS << "conversion failed";
6766 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006767
John Wiegley429bb272011-04-08 18:41:53 +00006768 case FK_ConversionFromPropertyFailed:
6769 OS << "conversion from property failed";
6770 break;
6771
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006772 case FK_TooManyInitsForScalar:
6773 OS << "too many initializers for scalar";
6774 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006775
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006776 case FK_ReferenceBindingToInitList:
6777 OS << "referencing binding to initializer list";
6778 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006779
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006780 case FK_InitListBadDestinationType:
6781 OS << "initializer list for non-aggregate, non-scalar type";
6782 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006783
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006784 case FK_UserConversionOverloadFailed:
6785 OS << "overloading failed for user-defined conversion";
6786 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006787
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006788 case FK_ConstructorOverloadFailed:
6789 OS << "constructor overloading failed";
6790 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006791
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006792 case FK_DefaultInitOfConst:
6793 OS << "default initialization of a const variable";
6794 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006795
Douglas Gregor72a43bb2010-05-20 22:12:02 +00006796 case FK_Incomplete:
6797 OS << "initialization of incomplete type";
6798 break;
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006799
6800 case FK_ListInitializationFailed:
Sebastian Redl14b0c192011-09-24 17:48:00 +00006801 OS << "list initialization checker failure";
John McCall5acb0c92011-10-17 18:40:02 +00006802 break;
6803
John McCall73076432012-01-05 00:13:19 +00006804 case FK_VariableLengthArrayHasInitializer:
6805 OS << "variable length array has an initializer";
6806 break;
6807
John McCall5acb0c92011-10-17 18:40:02 +00006808 case FK_PlaceholderType:
6809 OS << "initializer expression isn't contextually valid";
6810 break;
Nick Lewyckyb0c6c332011-12-22 20:21:32 +00006811
6812 case FK_ListConstructorOverloadFailed:
6813 OS << "list constructor overloading failed";
6814 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006815
Sebastian Redl70e24fc2012-04-01 19:54:59 +00006816 case FK_ExplicitConstructor:
6817 OS << "list copy initialization chose explicit constructor";
6818 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006819 }
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006820 OS << '\n';
6821 return;
6822 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006823
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006824 case DependentSequence:
Sebastian Redl7491c492011-06-05 13:59:11 +00006825 OS << "Dependent sequence\n";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006826 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006827
Sebastian Redl7491c492011-06-05 13:59:11 +00006828 case NormalSequence:
6829 OS << "Normal sequence: ";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006830 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006831 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006832
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006833 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6834 if (S != step_begin()) {
6835 OS << " -> ";
6836 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006837
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006838 switch (S->Kind) {
6839 case SK_ResolveAddressOfOverloadedFunction:
6840 OS << "resolve address of overloaded function";
6841 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006842
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006843 case SK_CastDerivedToBaseRValue:
6844 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6845 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006846
Sebastian Redl906082e2010-07-20 04:20:21 +00006847 case SK_CastDerivedToBaseXValue:
6848 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
6849 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006850
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006851 case SK_CastDerivedToBaseLValue:
6852 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
6853 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006854
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006855 case SK_BindReference:
6856 OS << "bind reference to lvalue";
6857 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006858
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006859 case SK_BindReferenceToTemporary:
6860 OS << "bind reference to a temporary";
6861 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006862
Douglas Gregor523d46a2010-04-18 07:40:54 +00006863 case SK_ExtraneousCopyToTemporary:
6864 OS << "extraneous C++03 copy to temporary";
6865 break;
6866
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006867 case SK_UserConversion:
Benjamin Kramerb8989f22011-10-14 18:45:37 +00006868 OS << "user-defined conversion via " << *S->Function.Function;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006869 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006870
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006871 case SK_QualificationConversionRValue:
6872 OS << "qualification conversion (rvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006873 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006874
Sebastian Redl906082e2010-07-20 04:20:21 +00006875 case SK_QualificationConversionXValue:
6876 OS << "qualification conversion (xvalue)";
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006877 break;
Sebastian Redl906082e2010-07-20 04:20:21 +00006878
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006879 case SK_QualificationConversionLValue:
6880 OS << "qualification conversion (lvalue)";
6881 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006882
Jordan Rose1fd1e282013-04-11 00:58:58 +00006883 case SK_LValueToRValue:
6884 OS << "load (lvalue to rvalue)";
6885 break;
6886
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006887 case SK_ConversionSequence:
6888 OS << "implicit conversion sequence (";
Douglas Gregor2f8b0cc2013-11-08 02:16:10 +00006889 S->ICS->dump(); // FIXME: use OS
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006890 OS << ")";
6891 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006892
Richard Smith13b228d2013-09-21 21:19:19 +00006893 case SK_ConversionSequenceNoNarrowing:
6894 OS << "implicit conversion sequence with narrowing prohibited (";
Douglas Gregor2f8b0cc2013-11-08 02:16:10 +00006895 S->ICS->dump(); // FIXME: use OS
Richard Smith13b228d2013-09-21 21:19:19 +00006896 OS << ")";
6897 break;
6898
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006899 case SK_ListInitialization:
Sebastian Redl8713d4e2011-09-24 17:47:52 +00006900 OS << "list aggregate initialization";
6901 break;
6902
6903 case SK_ListConstructorCall:
6904 OS << "list initialization via constructor";
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006905 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006906
Sebastian Redl13dc8f92011-11-27 16:50:07 +00006907 case SK_UnwrapInitList:
6908 OS << "unwrap reference initializer list";
6909 break;
6910
6911 case SK_RewrapInitList:
6912 OS << "rewrap reference initializer list";
6913 break;
6914
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006915 case SK_ConstructorInitialization:
6916 OS << "constructor initialization";
6917 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006918
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006919 case SK_ZeroInitialization:
6920 OS << "zero initialization";
6921 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006922
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006923 case SK_CAssignment:
6924 OS << "C assignment";
6925 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00006926
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006927 case SK_StringInit:
6928 OS << "string initialization";
6929 break;
Douglas Gregor569c3162010-08-07 11:51:51 +00006930
6931 case SK_ObjCObjectConversion:
6932 OS << "Objective-C object conversion";
6933 break;
Douglas Gregorcd9ec3b2011-02-22 18:29:51 +00006934
6935 case SK_ArrayInit:
6936 OS << "array initialization";
6937 break;
John McCallf85e1932011-06-15 23:02:42 +00006938
Richard Smith0f163e92012-02-15 22:38:09 +00006939 case SK_ParenthesizedArrayInit:
6940 OS << "parenthesized array initialization";
6941 break;
6942
John McCallf85e1932011-06-15 23:02:42 +00006943 case SK_PassByIndirectCopyRestore:
6944 OS << "pass by indirect copy and restore";
6945 break;
6946
6947 case SK_PassByIndirectRestore:
6948 OS << "pass by indirect restore";
6949 break;
6950
6951 case SK_ProduceObjCObject:
6952 OS << "Objective-C object retension";
6953 break;
Sebastian Redl2b916b82012-01-17 22:49:42 +00006954
6955 case SK_StdInitializerList:
6956 OS << "std::initializer_list from initializer list";
6957 break;
Guy Benyeie6b9d802013-01-20 12:31:11 +00006958
Guy Benyei21f18c42013-02-07 10:55:47 +00006959 case SK_OCLSamplerInit:
6960 OS << "OpenCL sampler_t from integer constant";
6961 break;
6962
Guy Benyeie6b9d802013-01-20 12:31:11 +00006963 case SK_OCLZeroEvent:
6964 OS << "OpenCL event_t from zero";
6965 break;
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006966 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006967
6968 OS << " [" << S->Type.getAsString() << ']';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006969 }
Richard Smitha4dc51b2013-02-05 05:52:24 +00006970
6971 OS << '\n';
Douglas Gregorde4b1d82010-01-29 19:14:02 +00006972}
6973
6974void InitializationSequence::dump() const {
6975 dump(llvm::errs());
6976}
6977
Richard Smith13b228d2013-09-21 21:19:19 +00006978static void DiagnoseNarrowingInInitList(Sema &S,
6979 const ImplicitConversionSequence &ICS,
6980 QualType PreNarrowingType,
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006981 QualType EntityType,
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006982 const Expr *PostInit) {
Stephen Hines6bcf27b2014-05-29 04:14:42 -07006983 const StandardConversionSequence *SCS = nullptr;
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006984 switch (ICS.getKind()) {
6985 case ImplicitConversionSequence::StandardConversion:
6986 SCS = &ICS.Standard;
6987 break;
6988 case ImplicitConversionSequence::UserDefinedConversion:
6989 SCS = &ICS.UserDefined.After;
6990 break;
6991 case ImplicitConversionSequence::AmbiguousConversion:
6992 case ImplicitConversionSequence::EllipsisConversion:
6993 case ImplicitConversionSequence::BadConversion:
6994 return;
6995 }
6996
Richard Smith4c3fc9b2012-01-18 05:21:49 +00006997 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
6998 APValue ConstantValue;
Richard Smithf6028062012-03-23 23:55:39 +00006999 QualType ConstantType;
7000 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7001 ConstantType)) {
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007002 case NK_Not_Narrowing:
7003 // No narrowing occurred.
7004 return;
7005
7006 case NK_Type_Narrowing:
7007 // This was a floating-to-integer conversion, which is always considered a
7008 // narrowing conversion even if the value is a constant and can be
7009 // represented exactly as an integer.
7010 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007011 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7012 ? diag::warn_init_list_type_narrowing
7013 : diag::ext_init_list_type_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007014 << PostInit->getSourceRange()
7015 << PreNarrowingType.getLocalUnqualifiedType()
7016 << EntityType.getLocalUnqualifiedType();
7017 break;
7018
7019 case NK_Constant_Narrowing:
7020 // A constant value was narrowed.
7021 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007022 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7023 ? diag::warn_init_list_constant_narrowing
7024 : diag::ext_init_list_constant_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007025 << PostInit->getSourceRange()
Richard Smithf6028062012-03-23 23:55:39 +00007026 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
Jeffrey Yasskin99061492011-08-29 15:59:37 +00007027 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007028 break;
7029
7030 case NK_Variable_Narrowing:
7031 // A variable's value may have been narrowed.
7032 S.Diag(PostInit->getLocStart(),
Richard Smith3347b492013-11-12 02:41:45 +00007033 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7034 ? diag::warn_init_list_variable_narrowing
7035 : diag::ext_init_list_variable_narrowing)
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007036 << PostInit->getSourceRange()
7037 << PreNarrowingType.getLocalUnqualifiedType()
Jeffrey Yasskin99061492011-08-29 15:59:37 +00007038 << EntityType.getLocalUnqualifiedType();
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007039 break;
7040 }
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007041
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00007042 SmallString<128> StaticCast;
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007043 llvm::raw_svector_ostream OS(StaticCast);
7044 OS << "static_cast<";
7045 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7046 // It's important to use the typedef's name if there is one so that the
7047 // fixit doesn't break code using types like int64_t.
7048 //
7049 // FIXME: This will break if the typedef requires qualification. But
7050 // getQualifiedNameAsString() includes non-machine-parsable components.
Benjamin Kramerb8989f22011-10-14 18:45:37 +00007051 OS << *TT->getDecl();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007052 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
David Blaikie4e4d0842012-03-11 07:00:24 +00007053 OS << BT->getName(S.getLangOpts());
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007054 else {
7055 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7056 // with a broken cast.
7057 return;
7058 }
7059 OS << ">(";
Stephen Hines6bcf27b2014-05-29 04:14:42 -07007060 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
7061 << PostInit->getSourceRange()
7062 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7063 << FixItHint::CreateInsertion(
7064 S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007065}
7066
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007067//===----------------------------------------------------------------------===//
7068// Initialization helper functions
7069//===----------------------------------------------------------------------===//
Sean Hunt2be7e902011-05-12 22:46:29 +00007070bool
7071Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7072 ExprResult Init) {
7073 if (Init.isInvalid())
7074 return false;
7075
7076 Expr *InitE = Init.get();
7077 assert(InitE && "No initialization expression");
7078
Douglas Gregor3c394c52012-07-31 22:15:04 +00007079 InitializationKind Kind
7080 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00007081 InitializationSequence Seq(*this, Entity, Kind, InitE);
Sebastian Redl383616c2011-06-05 12:23:28 +00007082 return !Seq.Failed();
Sean Hunt2be7e902011-05-12 22:46:29 +00007083}
7084
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00007085ExprResult
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007086Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7087 SourceLocation EqualLoc,
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007088 ExprResult Init,
Douglas Gregored878af2012-02-24 23:56:31 +00007089 bool TopLevelOfInitList,
7090 bool AllowExplicit) {
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007091 if (Init.isInvalid())
7092 return ExprError();
7093
John McCall15d7d122010-11-11 03:21:53 +00007094 Expr *InitE = Init.get();
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007095 assert(InitE && "No initialization expression?");
7096
7097 if (EqualLoc.isInvalid())
7098 EqualLoc = InitE->getLocStart();
7099
7100 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
Douglas Gregored878af2012-02-24 23:56:31 +00007101 EqualLoc,
7102 AllowExplicit);
Richard Smith13b228d2013-09-21 21:19:19 +00007103 InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007104 Init.release();
Jeffrey Yasskin19159132011-07-26 23:20:30 +00007105
Dmitri Gribenko1f78a502013-05-03 15:05:50 +00007106 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007107
Richard Smith4c3fc9b2012-01-18 05:21:49 +00007108 return Result;
Douglas Gregor18ef5e22009-12-18 05:02:21 +00007109}