1 //===--- 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 //
10 // This file implements semantic analysis for initializers.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Sema/Initialization.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/ExprCXX.h"
18 #include "clang/AST/ExprObjC.h"
19 #include "clang/AST/TypeLoc.h"
20 #include "clang/Basic/TargetInfo.h"
21 #include "clang/Sema/Designator.h"
22 #include "clang/Sema/Lookup.h"
23 #include "clang/Sema/SemaInternal.h"
24 #include "llvm/ADT/APInt.h"
25 #include "llvm/ADT/SmallString.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <map>
29 using namespace clang;
30
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
34
35 /// \brief Check whether T is compatible with a wide character type (wchar_t,
36 /// char16_t or char32_t).
IsWideCharCompatible(QualType T,ASTContext & Context)37 static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38 if (Context.typesAreCompatible(Context.getWideCharType(), T))
39 return true;
40 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41 return Context.typesAreCompatible(Context.Char16Ty, T) ||
42 Context.typesAreCompatible(Context.Char32Ty, T);
43 }
44 return false;
45 }
46
47 enum StringInitFailureKind {
48 SIF_None,
49 SIF_NarrowStringIntoWideChar,
50 SIF_WideStringIntoChar,
51 SIF_IncompatWideStringIntoWideChar,
52 SIF_Other
53 };
54
55 /// \brief Check whether the array of type AT can be initialized by the Init
56 /// expression by means of string initialization. Returns SIF_None if so,
57 /// otherwise returns a StringInitFailureKind that describes why the
58 /// initialization would not work.
IsStringInit(Expr * Init,const ArrayType * AT,ASTContext & Context)59 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
60 ASTContext &Context) {
61 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
62 return SIF_Other;
63
64 // See if this is a string literal or @encode.
65 Init = Init->IgnoreParens();
66
67 // Handle @encode, which is a narrow string.
68 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
69 return SIF_None;
70
71 // Otherwise we can only handle string literals.
72 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
73 if (!SL)
74 return SIF_Other;
75
76 const QualType ElemTy =
77 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
78
79 switch (SL->getKind()) {
80 case StringLiteral::Ascii:
81 case StringLiteral::UTF8:
82 // char array can be initialized with a narrow string.
83 // Only allow char x[] = "foo"; not char x[] = L"foo";
84 if (ElemTy->isCharType())
85 return SIF_None;
86 if (IsWideCharCompatible(ElemTy, Context))
87 return SIF_NarrowStringIntoWideChar;
88 return SIF_Other;
89 // C99 6.7.8p15 (with correction from DR343), or C11 6.7.9p15:
90 // "An array with element type compatible with a qualified or unqualified
91 // version of wchar_t, char16_t, or char32_t may be initialized by a wide
92 // string literal with the corresponding encoding prefix (L, u, or U,
93 // respectively), optionally enclosed in braces.
94 case StringLiteral::UTF16:
95 if (Context.typesAreCompatible(Context.Char16Ty, ElemTy))
96 return SIF_None;
97 if (ElemTy->isCharType())
98 return SIF_WideStringIntoChar;
99 if (IsWideCharCompatible(ElemTy, Context))
100 return SIF_IncompatWideStringIntoWideChar;
101 return SIF_Other;
102 case StringLiteral::UTF32:
103 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
104 return SIF_None;
105 if (ElemTy->isCharType())
106 return SIF_WideStringIntoChar;
107 if (IsWideCharCompatible(ElemTy, Context))
108 return SIF_IncompatWideStringIntoWideChar;
109 return SIF_Other;
110 case StringLiteral::Wide:
111 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
112 return SIF_None;
113 if (ElemTy->isCharType())
114 return SIF_WideStringIntoChar;
115 if (IsWideCharCompatible(ElemTy, Context))
116 return SIF_IncompatWideStringIntoWideChar;
117 return SIF_Other;
118 }
119
120 llvm_unreachable("missed a StringLiteral kind?");
121 }
122
IsStringInit(Expr * init,QualType declType,ASTContext & Context)123 static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
124 ASTContext &Context) {
125 const ArrayType *arrayType = Context.getAsArrayType(declType);
126 if (!arrayType)
127 return SIF_Other;
128 return IsStringInit(init, arrayType, Context);
129 }
130
131 /// Update the type of a string literal, including any surrounding parentheses,
132 /// to match the type of the object which it is initializing.
updateStringLiteralType(Expr * E,QualType Ty)133 static void updateStringLiteralType(Expr *E, QualType Ty) {
134 while (true) {
135 E->setType(Ty);
136 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
137 break;
138 else if (ParenExpr *PE = dyn_cast<ParenExpr>(E))
139 E = PE->getSubExpr();
140 else if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E))
141 E = UO->getSubExpr();
142 else if (GenericSelectionExpr *GSE = dyn_cast<GenericSelectionExpr>(E))
143 E = GSE->getResultExpr();
144 else
145 llvm_unreachable("unexpected expr in string literal init");
146 }
147 }
148
CheckStringInit(Expr * Str,QualType & DeclT,const ArrayType * AT,Sema & S)149 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
150 Sema &S) {
151 // Get the length of the string as parsed.
152 uint64_t StrLength =
153 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue();
154
155
156 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) {
157 // C99 6.7.8p14. We have an array of character type with unknown size
158 // being initialized to a string literal.
159 llvm::APInt ConstVal(32, StrLength);
160 // Return a new array type (C99 6.7.8p22).
161 DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
162 ConstVal,
163 ArrayType::Normal, 0);
164 updateStringLiteralType(Str, DeclT);
165 return;
166 }
167
168 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
169
170 // We have an array of character type with known size. However,
171 // the size may be smaller or larger than the string we are initializing.
172 // FIXME: Avoid truncation for 64-bit length strings.
173 if (S.getLangOpts().CPlusPlus) {
174 if (StringLiteral *SL = dyn_cast<StringLiteral>(Str->IgnoreParens())) {
175 // For Pascal strings it's OK to strip off the terminating null character,
176 // so the example below is valid:
177 //
178 // unsigned char a[2] = "\pa";
179 if (SL->isPascal())
180 StrLength--;
181 }
182
183 // [dcl.init.string]p2
184 if (StrLength > CAT->getSize().getZExtValue())
185 S.Diag(Str->getLocStart(),
186 diag::err_initializer_string_for_char_array_too_long)
187 << Str->getSourceRange();
188 } else {
189 // C99 6.7.8p14.
190 if (StrLength-1 > CAT->getSize().getZExtValue())
191 S.Diag(Str->getLocStart(),
192 diag::ext_initializer_string_for_char_array_too_long)
193 << Str->getSourceRange();
194 }
195
196 // Set the type to the actual size that we are initializing. If we have
197 // something like:
198 // char x[1] = "foo";
199 // then this will set the string literal's type to char[1].
200 updateStringLiteralType(Str, DeclT);
201 }
202
203 //===----------------------------------------------------------------------===//
204 // Semantic checking for initializer lists.
205 //===----------------------------------------------------------------------===//
206
207 /// @brief Semantic checking for initializer lists.
208 ///
209 /// The InitListChecker class contains a set of routines that each
210 /// handle the initialization of a certain kind of entity, e.g.,
211 /// arrays, vectors, struct/union types, scalars, etc. The
212 /// InitListChecker itself performs a recursive walk of the subobject
213 /// structure of the type to be initialized, while stepping through
214 /// the initializer list one element at a time. The IList and Index
215 /// parameters to each of the Check* routines contain the active
216 /// (syntactic) initializer list and the index into that initializer
217 /// list that represents the current initializer. Each routine is
218 /// responsible for moving that Index forward as it consumes elements.
219 ///
220 /// Each Check* routine also has a StructuredList/StructuredIndex
221 /// arguments, which contains the current "structured" (semantic)
222 /// initializer list and the index into that initializer list where we
223 /// are copying initializers as we map them over to the semantic
224 /// list. Once we have completed our recursive walk of the subobject
225 /// structure, we will have constructed a full semantic initializer
226 /// list.
227 ///
228 /// C99 designators cause changes in the initializer list traversal,
229 /// because they make the initialization "jump" into a specific
230 /// subobject and then continue the initialization from that
231 /// point. CheckDesignatedInitializer() recursively steps into the
232 /// designated subobject and manages backing out the recursion to
233 /// initialize the subobjects after the one designated.
234 namespace {
235 class InitListChecker {
236 Sema &SemaRef;
237 bool hadError;
238 bool VerifyOnly; // no diagnostics, no structure building
239 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
240 InitListExpr *FullyStructuredList;
241
242 void CheckImplicitInitList(const InitializedEntity &Entity,
243 InitListExpr *ParentIList, QualType T,
244 unsigned &Index, InitListExpr *StructuredList,
245 unsigned &StructuredIndex);
246 void CheckExplicitInitList(const InitializedEntity &Entity,
247 InitListExpr *IList, QualType &T,
248 InitListExpr *StructuredList,
249 bool TopLevelObject = false);
250 void CheckListElementTypes(const InitializedEntity &Entity,
251 InitListExpr *IList, QualType &DeclType,
252 bool SubobjectIsDesignatorContext,
253 unsigned &Index,
254 InitListExpr *StructuredList,
255 unsigned &StructuredIndex,
256 bool TopLevelObject = false);
257 void CheckSubElementType(const InitializedEntity &Entity,
258 InitListExpr *IList, QualType ElemType,
259 unsigned &Index,
260 InitListExpr *StructuredList,
261 unsigned &StructuredIndex);
262 void CheckComplexType(const InitializedEntity &Entity,
263 InitListExpr *IList, QualType DeclType,
264 unsigned &Index,
265 InitListExpr *StructuredList,
266 unsigned &StructuredIndex);
267 void CheckScalarType(const InitializedEntity &Entity,
268 InitListExpr *IList, QualType DeclType,
269 unsigned &Index,
270 InitListExpr *StructuredList,
271 unsigned &StructuredIndex);
272 void CheckReferenceType(const InitializedEntity &Entity,
273 InitListExpr *IList, QualType DeclType,
274 unsigned &Index,
275 InitListExpr *StructuredList,
276 unsigned &StructuredIndex);
277 void CheckVectorType(const InitializedEntity &Entity,
278 InitListExpr *IList, QualType DeclType, unsigned &Index,
279 InitListExpr *StructuredList,
280 unsigned &StructuredIndex);
281 void CheckStructUnionTypes(const InitializedEntity &Entity,
282 InitListExpr *IList, QualType DeclType,
283 RecordDecl::field_iterator Field,
284 bool SubobjectIsDesignatorContext, unsigned &Index,
285 InitListExpr *StructuredList,
286 unsigned &StructuredIndex,
287 bool TopLevelObject = false);
288 void CheckArrayType(const InitializedEntity &Entity,
289 InitListExpr *IList, QualType &DeclType,
290 llvm::APSInt elementIndex,
291 bool SubobjectIsDesignatorContext, unsigned &Index,
292 InitListExpr *StructuredList,
293 unsigned &StructuredIndex);
294 bool CheckDesignatedInitializer(const InitializedEntity &Entity,
295 InitListExpr *IList, DesignatedInitExpr *DIE,
296 unsigned DesigIdx,
297 QualType &CurrentObjectType,
298 RecordDecl::field_iterator *NextField,
299 llvm::APSInt *NextElementIndex,
300 unsigned &Index,
301 InitListExpr *StructuredList,
302 unsigned &StructuredIndex,
303 bool FinishSubobjectInit,
304 bool TopLevelObject);
305 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
306 QualType CurrentObjectType,
307 InitListExpr *StructuredList,
308 unsigned StructuredIndex,
309 SourceRange InitRange);
310 void UpdateStructuredListElement(InitListExpr *StructuredList,
311 unsigned &StructuredIndex,
312 Expr *expr);
313 int numArrayElements(QualType DeclType);
314 int numStructUnionElements(QualType DeclType);
315
316 static ExprResult PerformEmptyInit(Sema &SemaRef,
317 SourceLocation Loc,
318 const InitializedEntity &Entity,
319 bool VerifyOnly);
320 void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
321 const InitializedEntity &ParentEntity,
322 InitListExpr *ILE, bool &RequiresSecondPass);
323 void FillInEmptyInitializations(const InitializedEntity &Entity,
324 InitListExpr *ILE, bool &RequiresSecondPass);
325 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
326 Expr *InitExpr, FieldDecl *Field,
327 bool TopLevelObject);
328 void CheckEmptyInitializable(const InitializedEntity &Entity,
329 SourceLocation Loc);
330
331 public:
332 InitListChecker(Sema &S, const InitializedEntity &Entity,
333 InitListExpr *IL, QualType &T, bool VerifyOnly);
HadError()334 bool HadError() { return hadError; }
335
336 // @brief Retrieves the fully-structured initializer list used for
337 // semantic analysis and code generation.
getFullyStructuredList() const338 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
339 };
340 } // end anonymous namespace
341
PerformEmptyInit(Sema & SemaRef,SourceLocation Loc,const InitializedEntity & Entity,bool VerifyOnly)342 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
343 SourceLocation Loc,
344 const InitializedEntity &Entity,
345 bool VerifyOnly) {
346 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
347 true);
348 MultiExprArg SubInit;
349 Expr *InitExpr;
350 InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
351
352 // C++ [dcl.init.aggr]p7:
353 // If there are fewer initializer-clauses in the list than there are
354 // members in the aggregate, then each member not explicitly initialized
355 // ...
356 bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
357 Entity.getType()->getBaseElementTypeUnsafe()->isRecordType();
358 if (EmptyInitList) {
359 // C++1y / DR1070:
360 // shall be initialized [...] from an empty initializer list.
361 //
362 // We apply the resolution of this DR to C++11 but not C++98, since C++98
363 // does not have useful semantics for initialization from an init list.
364 // We treat this as copy-initialization, because aggregate initialization
365 // always performs copy-initialization on its elements.
366 //
367 // Only do this if we're initializing a class type, to avoid filling in
368 // the initializer list where possible.
369 InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
370 InitListExpr(SemaRef.Context, Loc, None, Loc);
371 InitExpr->setType(SemaRef.Context.VoidTy);
372 SubInit = InitExpr;
373 Kind = InitializationKind::CreateCopy(Loc, Loc);
374 } else {
375 // C++03:
376 // shall be value-initialized.
377 }
378
379 InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
380 // libstdc++4.6 marks the vector default constructor as explicit in
381 // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
382 // stlport does so too. Look for std::__debug for libstdc++, and for
383 // std:: for stlport. This is effectively a compiler-side implementation of
384 // LWG2193.
385 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
386 InitializationSequence::FK_ExplicitConstructor) {
387 OverloadCandidateSet::iterator Best;
388 OverloadingResult O =
389 InitSeq.getFailedCandidateSet()
390 .BestViableFunction(SemaRef, Kind.getLocation(), Best);
391 (void)O;
392 assert(O == OR_Success && "Inconsistent overload resolution");
393 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
394 CXXRecordDecl *R = CtorDecl->getParent();
395
396 if (CtorDecl->getMinRequiredArguments() == 0 &&
397 CtorDecl->isExplicit() && R->getDeclName() &&
398 SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
399
400
401 bool IsInStd = false;
402 for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
403 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
404 if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
405 IsInStd = true;
406 }
407
408 if (IsInStd && llvm::StringSwitch<bool>(R->getName())
409 .Cases("basic_string", "deque", "forward_list", true)
410 .Cases("list", "map", "multimap", "multiset", true)
411 .Cases("priority_queue", "queue", "set", "stack", true)
412 .Cases("unordered_map", "unordered_set", "vector", true)
413 .Default(false)) {
414 InitSeq.InitializeFrom(
415 SemaRef, Entity,
416 InitializationKind::CreateValue(Loc, Loc, Loc, true),
417 MultiExprArg(), /*TopLevelOfInitList=*/false);
418 // Emit a warning for this. System header warnings aren't shown
419 // by default, but people working on system headers should see it.
420 if (!VerifyOnly) {
421 SemaRef.Diag(CtorDecl->getLocation(),
422 diag::warn_invalid_initializer_from_system_header);
423 SemaRef.Diag(Entity.getDecl()->getLocation(),
424 diag::note_used_in_initialization_here);
425 }
426 }
427 }
428 }
429 if (!InitSeq) {
430 if (!VerifyOnly) {
431 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
432 if (Entity.getKind() == InitializedEntity::EK_Member)
433 SemaRef.Diag(Entity.getDecl()->getLocation(),
434 diag::note_in_omitted_aggregate_initializer)
435 << /*field*/1 << Entity.getDecl();
436 else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
437 SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
438 << /*array element*/0 << Entity.getElementIndex();
439 }
440 return ExprError();
441 }
442
443 return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
444 : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
445 }
446
CheckEmptyInitializable(const InitializedEntity & Entity,SourceLocation Loc)447 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
448 SourceLocation Loc) {
449 assert(VerifyOnly &&
450 "CheckEmptyInitializable is only inteded for verification mode.");
451 if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true).isInvalid())
452 hadError = true;
453 }
454
FillInEmptyInitForField(unsigned Init,FieldDecl * Field,const InitializedEntity & ParentEntity,InitListExpr * ILE,bool & RequiresSecondPass)455 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
456 const InitializedEntity &ParentEntity,
457 InitListExpr *ILE,
458 bool &RequiresSecondPass) {
459 SourceLocation Loc = ILE->getLocEnd();
460 unsigned NumInits = ILE->getNumInits();
461 InitializedEntity MemberEntity
462 = InitializedEntity::InitializeMember(Field, &ParentEntity);
463 if (Init >= NumInits || !ILE->getInit(Init)) {
464 // C++1y [dcl.init.aggr]p7:
465 // If there are fewer initializer-clauses in the list than there are
466 // members in the aggregate, then each member not explicitly initialized
467 // shall be initialized from its brace-or-equal-initializer [...]
468 if (Field->hasInClassInitializer()) {
469 ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
470 if (DIE.isInvalid()) {
471 hadError = true;
472 return;
473 }
474 if (Init < NumInits)
475 ILE->setInit(Init, DIE.get());
476 else {
477 ILE->updateInit(SemaRef.Context, Init, DIE.get());
478 RequiresSecondPass = true;
479 }
480 return;
481 }
482
483 if (Field->getType()->isReferenceType()) {
484 // C++ [dcl.init.aggr]p9:
485 // If an incomplete or empty initializer-list leaves a
486 // member of reference type uninitialized, the program is
487 // ill-formed.
488 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
489 << Field->getType()
490 << ILE->getSyntacticForm()->getSourceRange();
491 SemaRef.Diag(Field->getLocation(),
492 diag::note_uninit_reference_member);
493 hadError = true;
494 return;
495 }
496
497 ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
498 /*VerifyOnly*/false);
499 if (MemberInit.isInvalid()) {
500 hadError = true;
501 return;
502 }
503
504 if (hadError) {
505 // Do nothing
506 } else if (Init < NumInits) {
507 ILE->setInit(Init, MemberInit.getAs<Expr>());
508 } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
509 // Empty initialization requires a constructor call, so
510 // extend the initializer list to include the constructor
511 // call and make a note that we'll need to take another pass
512 // through the initializer list.
513 ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
514 RequiresSecondPass = true;
515 }
516 } else if (InitListExpr *InnerILE
517 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
518 FillInEmptyInitializations(MemberEntity, InnerILE,
519 RequiresSecondPass);
520 }
521
522 /// Recursively replaces NULL values within the given initializer list
523 /// with expressions that perform value-initialization of the
524 /// appropriate type.
525 void
FillInEmptyInitializations(const InitializedEntity & Entity,InitListExpr * ILE,bool & RequiresSecondPass)526 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
527 InitListExpr *ILE,
528 bool &RequiresSecondPass) {
529 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
530 "Should not have void type");
531
532 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
533 const RecordDecl *RDecl = RType->getDecl();
534 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
535 FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
536 Entity, ILE, RequiresSecondPass);
537 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
538 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
539 for (auto *Field : RDecl->fields()) {
540 if (Field->hasInClassInitializer()) {
541 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass);
542 break;
543 }
544 }
545 } else {
546 unsigned Init = 0;
547 for (auto *Field : RDecl->fields()) {
548 if (Field->isUnnamedBitfield())
549 continue;
550
551 if (hadError)
552 return;
553
554 FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass);
555 if (hadError)
556 return;
557
558 ++Init;
559
560 // Only look at the first initialization of a union.
561 if (RDecl->isUnion())
562 break;
563 }
564 }
565
566 return;
567 }
568
569 QualType ElementType;
570
571 InitializedEntity ElementEntity = Entity;
572 unsigned NumInits = ILE->getNumInits();
573 unsigned NumElements = NumInits;
574 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
575 ElementType = AType->getElementType();
576 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
577 NumElements = CAType->getSize().getZExtValue();
578 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
579 0, Entity);
580 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
581 ElementType = VType->getElementType();
582 NumElements = VType->getNumElements();
583 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
584 0, Entity);
585 } else
586 ElementType = ILE->getType();
587
588 for (unsigned Init = 0; Init != NumElements; ++Init) {
589 if (hadError)
590 return;
591
592 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
593 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
594 ElementEntity.setElementIndex(Init);
595
596 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
597 if (!InitExpr && !ILE->hasArrayFiller()) {
598 ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
599 ElementEntity,
600 /*VerifyOnly*/false);
601 if (ElementInit.isInvalid()) {
602 hadError = true;
603 return;
604 }
605
606 if (hadError) {
607 // Do nothing
608 } else if (Init < NumInits) {
609 // For arrays, just set the expression used for value-initialization
610 // of the "holes" in the array.
611 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
612 ILE->setArrayFiller(ElementInit.getAs<Expr>());
613 else
614 ILE->setInit(Init, ElementInit.getAs<Expr>());
615 } else {
616 // For arrays, just set the expression used for value-initialization
617 // of the rest of elements and exit.
618 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
619 ILE->setArrayFiller(ElementInit.getAs<Expr>());
620 return;
621 }
622
623 if (!isa<ImplicitValueInitExpr>(ElementInit.get())) {
624 // Empty initialization requires a constructor call, so
625 // extend the initializer list to include the constructor
626 // call and make a note that we'll need to take another pass
627 // through the initializer list.
628 ILE->updateInit(SemaRef.Context, Init, ElementInit.getAs<Expr>());
629 RequiresSecondPass = true;
630 }
631 }
632 } else if (InitListExpr *InnerILE
633 = dyn_cast_or_null<InitListExpr>(InitExpr))
634 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass);
635 }
636 }
637
638
InitListChecker(Sema & S,const InitializedEntity & Entity,InitListExpr * IL,QualType & T,bool VerifyOnly)639 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
640 InitListExpr *IL, QualType &T,
641 bool VerifyOnly)
642 : SemaRef(S), VerifyOnly(VerifyOnly) {
643 hadError = false;
644
645 FullyStructuredList =
646 getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
647 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
648 /*TopLevelObject=*/true);
649
650 if (!hadError && !VerifyOnly) {
651 bool RequiresSecondPass = false;
652 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
653 if (RequiresSecondPass && !hadError)
654 FillInEmptyInitializations(Entity, FullyStructuredList,
655 RequiresSecondPass);
656 }
657 }
658
numArrayElements(QualType DeclType)659 int InitListChecker::numArrayElements(QualType DeclType) {
660 // FIXME: use a proper constant
661 int maxElements = 0x7FFFFFFF;
662 if (const ConstantArrayType *CAT =
663 SemaRef.Context.getAsConstantArrayType(DeclType)) {
664 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
665 }
666 return maxElements;
667 }
668
numStructUnionElements(QualType DeclType)669 int InitListChecker::numStructUnionElements(QualType DeclType) {
670 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
671 int InitializableMembers = 0;
672 for (const auto *Field : structDecl->fields())
673 if (!Field->isUnnamedBitfield())
674 ++InitializableMembers;
675
676 if (structDecl->isUnion())
677 return std::min(InitializableMembers, 1);
678 return InitializableMembers - structDecl->hasFlexibleArrayMember();
679 }
680
681 /// Check whether the range of the initializer \p ParentIList from element
682 /// \p Index onwards can be used to initialize an object of type \p T. Update
683 /// \p Index to indicate how many elements of the list were consumed.
684 ///
685 /// This also fills in \p StructuredList, from element \p StructuredIndex
686 /// onwards, with the fully-braced, desugared form of the initialization.
CheckImplicitInitList(const InitializedEntity & Entity,InitListExpr * ParentIList,QualType T,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)687 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
688 InitListExpr *ParentIList,
689 QualType T, unsigned &Index,
690 InitListExpr *StructuredList,
691 unsigned &StructuredIndex) {
692 int maxElements = 0;
693
694 if (T->isArrayType())
695 maxElements = numArrayElements(T);
696 else if (T->isRecordType())
697 maxElements = numStructUnionElements(T);
698 else if (T->isVectorType())
699 maxElements = T->getAs<VectorType>()->getNumElements();
700 else
701 llvm_unreachable("CheckImplicitInitList(): Illegal type");
702
703 if (maxElements == 0) {
704 if (!VerifyOnly)
705 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
706 diag::err_implicit_empty_initializer);
707 ++Index;
708 hadError = true;
709 return;
710 }
711
712 // Build a structured initializer list corresponding to this subobject.
713 InitListExpr *StructuredSubobjectInitList
714 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
715 StructuredIndex,
716 SourceRange(ParentIList->getInit(Index)->getLocStart(),
717 ParentIList->getSourceRange().getEnd()));
718 unsigned StructuredSubobjectInitIndex = 0;
719
720 // Check the element types and build the structural subobject.
721 unsigned StartIndex = Index;
722 CheckListElementTypes(Entity, ParentIList, T,
723 /*SubobjectIsDesignatorContext=*/false, Index,
724 StructuredSubobjectInitList,
725 StructuredSubobjectInitIndex);
726
727 if (!VerifyOnly) {
728 StructuredSubobjectInitList->setType(T);
729
730 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
731 // Update the structured sub-object initializer so that it's ending
732 // range corresponds with the end of the last initializer it used.
733 if (EndIndex < ParentIList->getNumInits()) {
734 SourceLocation EndLoc
735 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
736 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
737 }
738
739 // Complain about missing braces.
740 if (T->isArrayType() || T->isRecordType()) {
741 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
742 diag::warn_missing_braces)
743 << StructuredSubobjectInitList->getSourceRange()
744 << FixItHint::CreateInsertion(
745 StructuredSubobjectInitList->getLocStart(), "{")
746 << FixItHint::CreateInsertion(
747 SemaRef.getLocForEndOfToken(
748 StructuredSubobjectInitList->getLocEnd()),
749 "}");
750 }
751 }
752 }
753
754 /// Check whether the initializer \p IList (that was written with explicit
755 /// braces) can be used to initialize an object of type \p T.
756 ///
757 /// This also fills in \p StructuredList with the fully-braced, desugared
758 /// form of the initialization.
CheckExplicitInitList(const InitializedEntity & Entity,InitListExpr * IList,QualType & T,InitListExpr * StructuredList,bool TopLevelObject)759 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
760 InitListExpr *IList, QualType &T,
761 InitListExpr *StructuredList,
762 bool TopLevelObject) {
763 if (!VerifyOnly) {
764 SyntacticToSemantic[IList] = StructuredList;
765 StructuredList->setSyntacticForm(IList);
766 }
767
768 unsigned Index = 0, StructuredIndex = 0;
769 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
770 Index, StructuredList, StructuredIndex, TopLevelObject);
771 if (!VerifyOnly) {
772 QualType ExprTy = T;
773 if (!ExprTy->isArrayType())
774 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
775 IList->setType(ExprTy);
776 StructuredList->setType(ExprTy);
777 }
778 if (hadError)
779 return;
780
781 if (Index < IList->getNumInits()) {
782 // We have leftover initializers
783 if (VerifyOnly) {
784 if (SemaRef.getLangOpts().CPlusPlus ||
785 (SemaRef.getLangOpts().OpenCL &&
786 IList->getType()->isVectorType())) {
787 hadError = true;
788 }
789 return;
790 }
791
792 if (StructuredIndex == 1 &&
793 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
794 SIF_None) {
795 unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
796 if (SemaRef.getLangOpts().CPlusPlus) {
797 DK = diag::err_excess_initializers_in_char_array_initializer;
798 hadError = true;
799 }
800 // Special-case
801 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
802 << IList->getInit(Index)->getSourceRange();
803 } else if (!T->isIncompleteType()) {
804 // Don't complain for incomplete types, since we'll get an error
805 // elsewhere
806 QualType CurrentObjectType = StructuredList->getType();
807 int initKind =
808 CurrentObjectType->isArrayType()? 0 :
809 CurrentObjectType->isVectorType()? 1 :
810 CurrentObjectType->isScalarType()? 2 :
811 CurrentObjectType->isUnionType()? 3 :
812 4;
813
814 unsigned DK = diag::ext_excess_initializers;
815 if (SemaRef.getLangOpts().CPlusPlus) {
816 DK = diag::err_excess_initializers;
817 hadError = true;
818 }
819 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
820 DK = diag::err_excess_initializers;
821 hadError = true;
822 }
823
824 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
825 << initKind << IList->getInit(Index)->getSourceRange();
826 }
827 }
828
829 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
830 !TopLevelObject)
831 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
832 << IList->getSourceRange()
833 << FixItHint::CreateRemoval(IList->getLocStart())
834 << FixItHint::CreateRemoval(IList->getLocEnd());
835 }
836
CheckListElementTypes(const InitializedEntity & Entity,InitListExpr * IList,QualType & DeclType,bool SubobjectIsDesignatorContext,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex,bool TopLevelObject)837 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
838 InitListExpr *IList,
839 QualType &DeclType,
840 bool SubobjectIsDesignatorContext,
841 unsigned &Index,
842 InitListExpr *StructuredList,
843 unsigned &StructuredIndex,
844 bool TopLevelObject) {
845 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
846 // Explicitly braced initializer for complex type can be real+imaginary
847 // parts.
848 CheckComplexType(Entity, IList, DeclType, Index,
849 StructuredList, StructuredIndex);
850 } else if (DeclType->isScalarType()) {
851 CheckScalarType(Entity, IList, DeclType, Index,
852 StructuredList, StructuredIndex);
853 } else if (DeclType->isVectorType()) {
854 CheckVectorType(Entity, IList, DeclType, Index,
855 StructuredList, StructuredIndex);
856 } else if (DeclType->isRecordType()) {
857 assert(DeclType->isAggregateType() &&
858 "non-aggregate records should be handed in CheckSubElementType");
859 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
860 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
861 SubobjectIsDesignatorContext, Index,
862 StructuredList, StructuredIndex,
863 TopLevelObject);
864 } else if (DeclType->isArrayType()) {
865 llvm::APSInt Zero(
866 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
867 false);
868 CheckArrayType(Entity, IList, DeclType, Zero,
869 SubobjectIsDesignatorContext, Index,
870 StructuredList, StructuredIndex);
871 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
872 // This type is invalid, issue a diagnostic.
873 ++Index;
874 if (!VerifyOnly)
875 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
876 << DeclType;
877 hadError = true;
878 } else if (DeclType->isReferenceType()) {
879 CheckReferenceType(Entity, IList, DeclType, Index,
880 StructuredList, StructuredIndex);
881 } else if (DeclType->isObjCObjectType()) {
882 if (!VerifyOnly)
883 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
884 << DeclType;
885 hadError = true;
886 } else {
887 if (!VerifyOnly)
888 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
889 << DeclType;
890 hadError = true;
891 }
892 }
893
CheckSubElementType(const InitializedEntity & Entity,InitListExpr * IList,QualType ElemType,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)894 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
895 InitListExpr *IList,
896 QualType ElemType,
897 unsigned &Index,
898 InitListExpr *StructuredList,
899 unsigned &StructuredIndex) {
900 Expr *expr = IList->getInit(Index);
901
902 if (ElemType->isReferenceType())
903 return CheckReferenceType(Entity, IList, ElemType, Index,
904 StructuredList, StructuredIndex);
905
906 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
907 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
908 InitListExpr *InnerStructuredList
909 = getStructuredSubobjectInit(IList, Index, ElemType,
910 StructuredList, StructuredIndex,
911 SubInitList->getSourceRange());
912 CheckExplicitInitList(Entity, SubInitList, ElemType,
913 InnerStructuredList);
914 ++StructuredIndex;
915 ++Index;
916 return;
917 }
918 assert(SemaRef.getLangOpts().CPlusPlus &&
919 "non-aggregate records are only possible in C++");
920 // C++ initialization is handled later.
921 } else if (isa<ImplicitValueInitExpr>(expr)) {
922 // This happens during template instantiation when we see an InitListExpr
923 // that we've already checked once.
924 assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
925 "found implicit initialization for the wrong type");
926 if (!VerifyOnly)
927 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
928 ++Index;
929 return;
930 }
931
932 // FIXME: Need to handle atomic aggregate types with implicit init lists.
933 if (ElemType->isScalarType() || ElemType->isAtomicType())
934 return CheckScalarType(Entity, IList, ElemType, Index,
935 StructuredList, StructuredIndex);
936
937 assert((ElemType->isRecordType() || ElemType->isVectorType() ||
938 ElemType->isArrayType()) && "Unexpected type");
939
940 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
941 // arrayType can be incomplete if we're initializing a flexible
942 // array member. There's nothing we can do with the completed
943 // type here, though.
944
945 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
946 if (!VerifyOnly) {
947 CheckStringInit(expr, ElemType, arrayType, SemaRef);
948 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
949 }
950 ++Index;
951 return;
952 }
953
954 // Fall through for subaggregate initialization.
955
956 } else if (SemaRef.getLangOpts().CPlusPlus) {
957 // C++ [dcl.init.aggr]p12:
958 // All implicit type conversions (clause 4) are considered when
959 // initializing the aggregate member with an initializer from
960 // an initializer-list. If the initializer can initialize a
961 // member, the member is initialized. [...]
962
963 // FIXME: Better EqualLoc?
964 InitializationKind Kind =
965 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
966 InitializationSequence Seq(SemaRef, Entity, Kind, expr);
967
968 if (Seq) {
969 if (!VerifyOnly) {
970 ExprResult Result =
971 Seq.Perform(SemaRef, Entity, Kind, expr);
972 if (Result.isInvalid())
973 hadError = true;
974
975 UpdateStructuredListElement(StructuredList, StructuredIndex,
976 Result.getAs<Expr>());
977 }
978 ++Index;
979 return;
980 }
981
982 // Fall through for subaggregate initialization
983 } else {
984 // C99 6.7.8p13:
985 //
986 // The initializer for a structure or union object that has
987 // automatic storage duration shall be either an initializer
988 // list as described below, or a single expression that has
989 // compatible structure or union type. In the latter case, the
990 // initial value of the object, including unnamed members, is
991 // that of the expression.
992 ExprResult ExprRes = expr;
993 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
994 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
995 !VerifyOnly)
996 != Sema::Incompatible) {
997 if (ExprRes.isInvalid())
998 hadError = true;
999 else {
1000 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1001 if (ExprRes.isInvalid())
1002 hadError = true;
1003 }
1004 UpdateStructuredListElement(StructuredList, StructuredIndex,
1005 ExprRes.getAs<Expr>());
1006 ++Index;
1007 return;
1008 }
1009 ExprRes.get();
1010 // Fall through for subaggregate initialization
1011 }
1012
1013 // C++ [dcl.init.aggr]p12:
1014 //
1015 // [...] Otherwise, if the member is itself a non-empty
1016 // subaggregate, brace elision is assumed and the initializer is
1017 // considered for the initialization of the first member of
1018 // the subaggregate.
1019 if (!SemaRef.getLangOpts().OpenCL &&
1020 (ElemType->isAggregateType() || ElemType->isVectorType())) {
1021 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1022 StructuredIndex);
1023 ++StructuredIndex;
1024 } else {
1025 if (!VerifyOnly) {
1026 // We cannot initialize this element, so let
1027 // PerformCopyInitialization produce the appropriate diagnostic.
1028 SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1029 /*TopLevelOfInitList=*/true);
1030 }
1031 hadError = true;
1032 ++Index;
1033 ++StructuredIndex;
1034 }
1035 }
1036
CheckComplexType(const InitializedEntity & Entity,InitListExpr * IList,QualType DeclType,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)1037 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1038 InitListExpr *IList, QualType DeclType,
1039 unsigned &Index,
1040 InitListExpr *StructuredList,
1041 unsigned &StructuredIndex) {
1042 assert(Index == 0 && "Index in explicit init list must be zero");
1043
1044 // As an extension, clang supports complex initializers, which initialize
1045 // a complex number component-wise. When an explicit initializer list for
1046 // a complex number contains two two initializers, this extension kicks in:
1047 // it exepcts the initializer list to contain two elements convertible to
1048 // the element type of the complex type. The first element initializes
1049 // the real part, and the second element intitializes the imaginary part.
1050
1051 if (IList->getNumInits() != 2)
1052 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1053 StructuredIndex);
1054
1055 // This is an extension in C. (The builtin _Complex type does not exist
1056 // in the C++ standard.)
1057 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1058 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1059 << IList->getSourceRange();
1060
1061 // Initialize the complex number.
1062 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1063 InitializedEntity ElementEntity =
1064 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1065
1066 for (unsigned i = 0; i < 2; ++i) {
1067 ElementEntity.setElementIndex(Index);
1068 CheckSubElementType(ElementEntity, IList, elementType, Index,
1069 StructuredList, StructuredIndex);
1070 }
1071 }
1072
1073
CheckScalarType(const InitializedEntity & Entity,InitListExpr * IList,QualType DeclType,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)1074 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1075 InitListExpr *IList, QualType DeclType,
1076 unsigned &Index,
1077 InitListExpr *StructuredList,
1078 unsigned &StructuredIndex) {
1079 if (Index >= IList->getNumInits()) {
1080 if (!VerifyOnly)
1081 SemaRef.Diag(IList->getLocStart(),
1082 SemaRef.getLangOpts().CPlusPlus11 ?
1083 diag::warn_cxx98_compat_empty_scalar_initializer :
1084 diag::err_empty_scalar_initializer)
1085 << IList->getSourceRange();
1086 hadError = !SemaRef.getLangOpts().CPlusPlus11;
1087 ++Index;
1088 ++StructuredIndex;
1089 return;
1090 }
1091
1092 Expr *expr = IList->getInit(Index);
1093 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1094 // FIXME: This is invalid, and accepting it causes overload resolution
1095 // to pick the wrong overload in some corner cases.
1096 if (!VerifyOnly)
1097 SemaRef.Diag(SubIList->getLocStart(),
1098 diag::ext_many_braces_around_scalar_init)
1099 << SubIList->getSourceRange();
1100
1101 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1102 StructuredIndex);
1103 return;
1104 } else if (isa<DesignatedInitExpr>(expr)) {
1105 if (!VerifyOnly)
1106 SemaRef.Diag(expr->getLocStart(),
1107 diag::err_designator_for_scalar_init)
1108 << DeclType << expr->getSourceRange();
1109 hadError = true;
1110 ++Index;
1111 ++StructuredIndex;
1112 return;
1113 }
1114
1115 if (VerifyOnly) {
1116 if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1117 hadError = true;
1118 ++Index;
1119 return;
1120 }
1121
1122 ExprResult Result =
1123 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1124 /*TopLevelOfInitList=*/true);
1125
1126 Expr *ResultExpr = nullptr;
1127
1128 if (Result.isInvalid())
1129 hadError = true; // types weren't compatible.
1130 else {
1131 ResultExpr = Result.getAs<Expr>();
1132
1133 if (ResultExpr != expr) {
1134 // The type was promoted, update initializer list.
1135 IList->setInit(Index, ResultExpr);
1136 }
1137 }
1138 if (hadError)
1139 ++StructuredIndex;
1140 else
1141 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1142 ++Index;
1143 }
1144
CheckReferenceType(const InitializedEntity & Entity,InitListExpr * IList,QualType DeclType,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)1145 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1146 InitListExpr *IList, QualType DeclType,
1147 unsigned &Index,
1148 InitListExpr *StructuredList,
1149 unsigned &StructuredIndex) {
1150 if (Index >= IList->getNumInits()) {
1151 // FIXME: It would be wonderful if we could point at the actual member. In
1152 // general, it would be useful to pass location information down the stack,
1153 // so that we know the location (or decl) of the "current object" being
1154 // initialized.
1155 if (!VerifyOnly)
1156 SemaRef.Diag(IList->getLocStart(),
1157 diag::err_init_reference_member_uninitialized)
1158 << DeclType
1159 << IList->getSourceRange();
1160 hadError = true;
1161 ++Index;
1162 ++StructuredIndex;
1163 return;
1164 }
1165
1166 Expr *expr = IList->getInit(Index);
1167 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1168 if (!VerifyOnly)
1169 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1170 << DeclType << IList->getSourceRange();
1171 hadError = true;
1172 ++Index;
1173 ++StructuredIndex;
1174 return;
1175 }
1176
1177 if (VerifyOnly) {
1178 if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1179 hadError = true;
1180 ++Index;
1181 return;
1182 }
1183
1184 ExprResult Result =
1185 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1186 /*TopLevelOfInitList=*/true);
1187
1188 if (Result.isInvalid())
1189 hadError = true;
1190
1191 expr = Result.getAs<Expr>();
1192 IList->setInit(Index, expr);
1193
1194 if (hadError)
1195 ++StructuredIndex;
1196 else
1197 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1198 ++Index;
1199 }
1200
CheckVectorType(const InitializedEntity & Entity,InitListExpr * IList,QualType DeclType,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)1201 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1202 InitListExpr *IList, QualType DeclType,
1203 unsigned &Index,
1204 InitListExpr *StructuredList,
1205 unsigned &StructuredIndex) {
1206 const VectorType *VT = DeclType->getAs<VectorType>();
1207 unsigned maxElements = VT->getNumElements();
1208 unsigned numEltsInit = 0;
1209 QualType elementType = VT->getElementType();
1210
1211 if (Index >= IList->getNumInits()) {
1212 // Make sure the element type can be value-initialized.
1213 if (VerifyOnly)
1214 CheckEmptyInitializable(
1215 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1216 IList->getLocEnd());
1217 return;
1218 }
1219
1220 if (!SemaRef.getLangOpts().OpenCL) {
1221 // If the initializing element is a vector, try to copy-initialize
1222 // instead of breaking it apart (which is doomed to failure anyway).
1223 Expr *Init = IList->getInit(Index);
1224 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1225 if (VerifyOnly) {
1226 if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1227 hadError = true;
1228 ++Index;
1229 return;
1230 }
1231
1232 ExprResult Result =
1233 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1234 /*TopLevelOfInitList=*/true);
1235
1236 Expr *ResultExpr = nullptr;
1237 if (Result.isInvalid())
1238 hadError = true; // types weren't compatible.
1239 else {
1240 ResultExpr = Result.getAs<Expr>();
1241
1242 if (ResultExpr != Init) {
1243 // The type was promoted, update initializer list.
1244 IList->setInit(Index, ResultExpr);
1245 }
1246 }
1247 if (hadError)
1248 ++StructuredIndex;
1249 else
1250 UpdateStructuredListElement(StructuredList, StructuredIndex,
1251 ResultExpr);
1252 ++Index;
1253 return;
1254 }
1255
1256 InitializedEntity ElementEntity =
1257 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1258
1259 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1260 // Don't attempt to go past the end of the init list
1261 if (Index >= IList->getNumInits()) {
1262 if (VerifyOnly)
1263 CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1264 break;
1265 }
1266
1267 ElementEntity.setElementIndex(Index);
1268 CheckSubElementType(ElementEntity, IList, elementType, Index,
1269 StructuredList, StructuredIndex);
1270 }
1271
1272 if (VerifyOnly)
1273 return;
1274
1275 bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1276 const VectorType *T = Entity.getType()->getAs<VectorType>();
1277 if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1278 T->getVectorKind() == VectorType::NeonPolyVector)) {
1279 // The ability to use vector initializer lists is a GNU vector extension
1280 // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1281 // endian machines it works fine, however on big endian machines it
1282 // exhibits surprising behaviour:
1283 //
1284 // uint32x2_t x = {42, 64};
1285 // return vget_lane_u32(x, 0); // Will return 64.
1286 //
1287 // Because of this, explicitly call out that it is non-portable.
1288 //
1289 SemaRef.Diag(IList->getLocStart(),
1290 diag::warn_neon_vector_initializer_non_portable);
1291
1292 const char *typeCode;
1293 unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1294
1295 if (elementType->isFloatingType())
1296 typeCode = "f";
1297 else if (elementType->isSignedIntegerType())
1298 typeCode = "s";
1299 else if (elementType->isUnsignedIntegerType())
1300 typeCode = "u";
1301 else
1302 llvm_unreachable("Invalid element type!");
1303
1304 SemaRef.Diag(IList->getLocStart(),
1305 SemaRef.Context.getTypeSize(VT) > 64 ?
1306 diag::note_neon_vector_initializer_non_portable_q :
1307 diag::note_neon_vector_initializer_non_portable)
1308 << typeCode << typeSize;
1309 }
1310
1311 return;
1312 }
1313
1314 InitializedEntity ElementEntity =
1315 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1316
1317 // OpenCL initializers allows vectors to be constructed from vectors.
1318 for (unsigned i = 0; i < maxElements; ++i) {
1319 // Don't attempt to go past the end of the init list
1320 if (Index >= IList->getNumInits())
1321 break;
1322
1323 ElementEntity.setElementIndex(Index);
1324
1325 QualType IType = IList->getInit(Index)->getType();
1326 if (!IType->isVectorType()) {
1327 CheckSubElementType(ElementEntity, IList, elementType, Index,
1328 StructuredList, StructuredIndex);
1329 ++numEltsInit;
1330 } else {
1331 QualType VecType;
1332 const VectorType *IVT = IType->getAs<VectorType>();
1333 unsigned numIElts = IVT->getNumElements();
1334
1335 if (IType->isExtVectorType())
1336 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1337 else
1338 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1339 IVT->getVectorKind());
1340 CheckSubElementType(ElementEntity, IList, VecType, Index,
1341 StructuredList, StructuredIndex);
1342 numEltsInit += numIElts;
1343 }
1344 }
1345
1346 // OpenCL requires all elements to be initialized.
1347 if (numEltsInit != maxElements) {
1348 if (!VerifyOnly)
1349 SemaRef.Diag(IList->getLocStart(),
1350 diag::err_vector_incorrect_num_initializers)
1351 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1352 hadError = true;
1353 }
1354 }
1355
CheckArrayType(const InitializedEntity & Entity,InitListExpr * IList,QualType & DeclType,llvm::APSInt elementIndex,bool SubobjectIsDesignatorContext,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex)1356 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1357 InitListExpr *IList, QualType &DeclType,
1358 llvm::APSInt elementIndex,
1359 bool SubobjectIsDesignatorContext,
1360 unsigned &Index,
1361 InitListExpr *StructuredList,
1362 unsigned &StructuredIndex) {
1363 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1364
1365 // Check for the special-case of initializing an array with a string.
1366 if (Index < IList->getNumInits()) {
1367 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1368 SIF_None) {
1369 // We place the string literal directly into the resulting
1370 // initializer list. This is the only place where the structure
1371 // of the structured initializer list doesn't match exactly,
1372 // because doing so would involve allocating one character
1373 // constant for each string.
1374 if (!VerifyOnly) {
1375 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1376 UpdateStructuredListElement(StructuredList, StructuredIndex,
1377 IList->getInit(Index));
1378 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1379 }
1380 ++Index;
1381 return;
1382 }
1383 }
1384 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1385 // Check for VLAs; in standard C it would be possible to check this
1386 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1387 // them in all sorts of strange places).
1388 if (!VerifyOnly)
1389 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1390 diag::err_variable_object_no_init)
1391 << VAT->getSizeExpr()->getSourceRange();
1392 hadError = true;
1393 ++Index;
1394 ++StructuredIndex;
1395 return;
1396 }
1397
1398 // We might know the maximum number of elements in advance.
1399 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1400 elementIndex.isUnsigned());
1401 bool maxElementsKnown = false;
1402 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1403 maxElements = CAT->getSize();
1404 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1405 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1406 maxElementsKnown = true;
1407 }
1408
1409 QualType elementType = arrayType->getElementType();
1410 while (Index < IList->getNumInits()) {
1411 Expr *Init = IList->getInit(Index);
1412 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1413 // If we're not the subobject that matches up with the '{' for
1414 // the designator, we shouldn't be handling the
1415 // designator. Return immediately.
1416 if (!SubobjectIsDesignatorContext)
1417 return;
1418
1419 // Handle this designated initializer. elementIndex will be
1420 // updated to be the next array element we'll initialize.
1421 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1422 DeclType, nullptr, &elementIndex, Index,
1423 StructuredList, StructuredIndex, true,
1424 false)) {
1425 hadError = true;
1426 continue;
1427 }
1428
1429 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1430 maxElements = maxElements.extend(elementIndex.getBitWidth());
1431 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1432 elementIndex = elementIndex.extend(maxElements.getBitWidth());
1433 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1434
1435 // If the array is of incomplete type, keep track of the number of
1436 // elements in the initializer.
1437 if (!maxElementsKnown && elementIndex > maxElements)
1438 maxElements = elementIndex;
1439
1440 continue;
1441 }
1442
1443 // If we know the maximum number of elements, and we've already
1444 // hit it, stop consuming elements in the initializer list.
1445 if (maxElementsKnown && elementIndex == maxElements)
1446 break;
1447
1448 InitializedEntity ElementEntity =
1449 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1450 Entity);
1451 // Check this element.
1452 CheckSubElementType(ElementEntity, IList, elementType, Index,
1453 StructuredList, StructuredIndex);
1454 ++elementIndex;
1455
1456 // If the array is of incomplete type, keep track of the number of
1457 // elements in the initializer.
1458 if (!maxElementsKnown && elementIndex > maxElements)
1459 maxElements = elementIndex;
1460 }
1461 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1462 // If this is an incomplete array type, the actual type needs to
1463 // be calculated here.
1464 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1465 if (maxElements == Zero) {
1466 // Sizing an array implicitly to zero is not allowed by ISO C,
1467 // but is supported by GNU.
1468 SemaRef.Diag(IList->getLocStart(),
1469 diag::ext_typecheck_zero_array_size);
1470 }
1471
1472 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1473 ArrayType::Normal, 0);
1474 }
1475 if (!hadError && VerifyOnly) {
1476 // Check if there are any members of the array that get value-initialized.
1477 // If so, check if doing that is possible.
1478 // FIXME: This needs to detect holes left by designated initializers too.
1479 if (maxElementsKnown && elementIndex < maxElements)
1480 CheckEmptyInitializable(InitializedEntity::InitializeElement(
1481 SemaRef.Context, 0, Entity),
1482 IList->getLocEnd());
1483 }
1484 }
1485
CheckFlexibleArrayInit(const InitializedEntity & Entity,Expr * InitExpr,FieldDecl * Field,bool TopLevelObject)1486 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1487 Expr *InitExpr,
1488 FieldDecl *Field,
1489 bool TopLevelObject) {
1490 // Handle GNU flexible array initializers.
1491 unsigned FlexArrayDiag;
1492 if (isa<InitListExpr>(InitExpr) &&
1493 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1494 // Empty flexible array init always allowed as an extension
1495 FlexArrayDiag = diag::ext_flexible_array_init;
1496 } else if (SemaRef.getLangOpts().CPlusPlus) {
1497 // Disallow flexible array init in C++; it is not required for gcc
1498 // compatibility, and it needs work to IRGen correctly in general.
1499 FlexArrayDiag = diag::err_flexible_array_init;
1500 } else if (!TopLevelObject) {
1501 // Disallow flexible array init on non-top-level object
1502 FlexArrayDiag = diag::err_flexible_array_init;
1503 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1504 // Disallow flexible array init on anything which is not a variable.
1505 FlexArrayDiag = diag::err_flexible_array_init;
1506 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1507 // Disallow flexible array init on local variables.
1508 FlexArrayDiag = diag::err_flexible_array_init;
1509 } else {
1510 // Allow other cases.
1511 FlexArrayDiag = diag::ext_flexible_array_init;
1512 }
1513
1514 if (!VerifyOnly) {
1515 SemaRef.Diag(InitExpr->getLocStart(),
1516 FlexArrayDiag)
1517 << InitExpr->getLocStart();
1518 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1519 << Field;
1520 }
1521
1522 return FlexArrayDiag != diag::ext_flexible_array_init;
1523 }
1524
CheckStructUnionTypes(const InitializedEntity & Entity,InitListExpr * IList,QualType DeclType,RecordDecl::field_iterator Field,bool SubobjectIsDesignatorContext,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex,bool TopLevelObject)1525 void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
1526 InitListExpr *IList,
1527 QualType DeclType,
1528 RecordDecl::field_iterator Field,
1529 bool SubobjectIsDesignatorContext,
1530 unsigned &Index,
1531 InitListExpr *StructuredList,
1532 unsigned &StructuredIndex,
1533 bool TopLevelObject) {
1534 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
1535
1536 // If the record is invalid, some of it's members are invalid. To avoid
1537 // confusion, we forgo checking the intializer for the entire record.
1538 if (structDecl->isInvalidDecl()) {
1539 // Assume it was supposed to consume a single initializer.
1540 ++Index;
1541 hadError = true;
1542 return;
1543 }
1544
1545 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1546 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1547
1548 // If there's a default initializer, use it.
1549 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1550 if (VerifyOnly)
1551 return;
1552 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1553 Field != FieldEnd; ++Field) {
1554 if (Field->hasInClassInitializer()) {
1555 StructuredList->setInitializedFieldInUnion(*Field);
1556 // FIXME: Actually build a CXXDefaultInitExpr?
1557 return;
1558 }
1559 }
1560 }
1561
1562 // Value-initialize the first member of the union that isn't an unnamed
1563 // bitfield.
1564 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1565 Field != FieldEnd; ++Field) {
1566 if (!Field->isUnnamedBitfield()) {
1567 if (VerifyOnly)
1568 CheckEmptyInitializable(
1569 InitializedEntity::InitializeMember(*Field, &Entity),
1570 IList->getLocEnd());
1571 else
1572 StructuredList->setInitializedFieldInUnion(*Field);
1573 break;
1574 }
1575 }
1576 return;
1577 }
1578
1579 // If structDecl is a forward declaration, this loop won't do
1580 // anything except look at designated initializers; That's okay,
1581 // because an error should get printed out elsewhere. It might be
1582 // worthwhile to skip over the rest of the initializer, though.
1583 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1584 RecordDecl::field_iterator FieldEnd = RD->field_end();
1585 bool InitializedSomething = false;
1586 bool CheckForMissingFields = true;
1587 while (Index < IList->getNumInits()) {
1588 Expr *Init = IList->getInit(Index);
1589
1590 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1591 // If we're not the subobject that matches up with the '{' for
1592 // the designator, we shouldn't be handling the
1593 // designator. Return immediately.
1594 if (!SubobjectIsDesignatorContext)
1595 return;
1596
1597 // Handle this designated initializer. Field will be updated to
1598 // the next field that we'll be initializing.
1599 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1600 DeclType, &Field, nullptr, Index,
1601 StructuredList, StructuredIndex,
1602 true, TopLevelObject))
1603 hadError = true;
1604
1605 InitializedSomething = true;
1606
1607 // Disable check for missing fields when designators are used.
1608 // This matches gcc behaviour.
1609 CheckForMissingFields = false;
1610 continue;
1611 }
1612
1613 if (Field == FieldEnd) {
1614 // We've run out of fields. We're done.
1615 break;
1616 }
1617
1618 // We've already initialized a member of a union. We're done.
1619 if (InitializedSomething && DeclType->isUnionType())
1620 break;
1621
1622 // If we've hit the flexible array member at the end, we're done.
1623 if (Field->getType()->isIncompleteArrayType())
1624 break;
1625
1626 if (Field->isUnnamedBitfield()) {
1627 // Don't initialize unnamed bitfields, e.g. "int : 20;"
1628 ++Field;
1629 continue;
1630 }
1631
1632 // Make sure we can use this declaration.
1633 bool InvalidUse;
1634 if (VerifyOnly)
1635 InvalidUse = !SemaRef.CanUseDecl(*Field);
1636 else
1637 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1638 IList->getInit(Index)->getLocStart());
1639 if (InvalidUse) {
1640 ++Index;
1641 ++Field;
1642 hadError = true;
1643 continue;
1644 }
1645
1646 InitializedEntity MemberEntity =
1647 InitializedEntity::InitializeMember(*Field, &Entity);
1648 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1649 StructuredList, StructuredIndex);
1650 InitializedSomething = true;
1651
1652 if (DeclType->isUnionType() && !VerifyOnly) {
1653 // Initialize the first field within the union.
1654 StructuredList->setInitializedFieldInUnion(*Field);
1655 }
1656
1657 ++Field;
1658 }
1659
1660 // Emit warnings for missing struct field initializers.
1661 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1662 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1663 !DeclType->isUnionType()) {
1664 // It is possible we have one or more unnamed bitfields remaining.
1665 // Find first (if any) named field and emit warning.
1666 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1667 it != end; ++it) {
1668 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1669 SemaRef.Diag(IList->getSourceRange().getEnd(),
1670 diag::warn_missing_field_initializers) << *it;
1671 break;
1672 }
1673 }
1674 }
1675
1676 // Check that any remaining fields can be value-initialized.
1677 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1678 !Field->getType()->isIncompleteArrayType()) {
1679 // FIXME: Should check for holes left by designated initializers too.
1680 for (; Field != FieldEnd && !hadError; ++Field) {
1681 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1682 CheckEmptyInitializable(
1683 InitializedEntity::InitializeMember(*Field, &Entity),
1684 IList->getLocEnd());
1685 }
1686 }
1687
1688 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1689 Index >= IList->getNumInits())
1690 return;
1691
1692 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1693 TopLevelObject)) {
1694 hadError = true;
1695 ++Index;
1696 return;
1697 }
1698
1699 InitializedEntity MemberEntity =
1700 InitializedEntity::InitializeMember(*Field, &Entity);
1701
1702 if (isa<InitListExpr>(IList->getInit(Index)))
1703 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1704 StructuredList, StructuredIndex);
1705 else
1706 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1707 StructuredList, StructuredIndex);
1708 }
1709
1710 /// \brief Expand a field designator that refers to a member of an
1711 /// anonymous struct or union into a series of field designators that
1712 /// refers to the field within the appropriate subobject.
1713 ///
ExpandAnonymousFieldDesignator(Sema & SemaRef,DesignatedInitExpr * DIE,unsigned DesigIdx,IndirectFieldDecl * IndirectField)1714 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1715 DesignatedInitExpr *DIE,
1716 unsigned DesigIdx,
1717 IndirectFieldDecl *IndirectField) {
1718 typedef DesignatedInitExpr::Designator Designator;
1719
1720 // Build the replacement designators.
1721 SmallVector<Designator, 4> Replacements;
1722 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1723 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1724 if (PI + 1 == PE)
1725 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1726 DIE->getDesignator(DesigIdx)->getDotLoc(),
1727 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1728 else
1729 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1730 SourceLocation(), SourceLocation()));
1731 assert(isa<FieldDecl>(*PI));
1732 Replacements.back().setField(cast<FieldDecl>(*PI));
1733 }
1734
1735 // Expand the current designator into the set of replacement
1736 // designators, so we have a full subobject path down to where the
1737 // member of the anonymous struct/union is actually stored.
1738 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1739 &Replacements[0] + Replacements.size());
1740 }
1741
CloneDesignatedInitExpr(Sema & SemaRef,DesignatedInitExpr * DIE)1742 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1743 DesignatedInitExpr *DIE) {
1744 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1745 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1746 for (unsigned I = 0; I < NumIndexExprs; ++I)
1747 IndexExprs[I] = DIE->getSubExpr(I + 1);
1748 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
1749 DIE->size(), IndexExprs,
1750 DIE->getEqualOrColonLoc(),
1751 DIE->usesGNUSyntax(), DIE->getInit());
1752 }
1753
1754 namespace {
1755
1756 // Callback to only accept typo corrections that are for field members of
1757 // the given struct or union.
1758 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1759 public:
FieldInitializerValidatorCCC(RecordDecl * RD)1760 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1761 : Record(RD) {}
1762
ValidateCandidate(const TypoCorrection & candidate)1763 bool ValidateCandidate(const TypoCorrection &candidate) override {
1764 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1765 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1766 }
1767
1768 private:
1769 RecordDecl *Record;
1770 };
1771
1772 }
1773
1774 /// @brief Check the well-formedness of a C99 designated initializer.
1775 ///
1776 /// Determines whether the designated initializer @p DIE, which
1777 /// resides at the given @p Index within the initializer list @p
1778 /// IList, is well-formed for a current object of type @p DeclType
1779 /// (C99 6.7.8). The actual subobject that this designator refers to
1780 /// within the current subobject is returned in either
1781 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1782 ///
1783 /// @param IList The initializer list in which this designated
1784 /// initializer occurs.
1785 ///
1786 /// @param DIE The designated initializer expression.
1787 ///
1788 /// @param DesigIdx The index of the current designator.
1789 ///
1790 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
1791 /// into which the designation in @p DIE should refer.
1792 ///
1793 /// @param NextField If non-NULL and the first designator in @p DIE is
1794 /// a field, this will be set to the field declaration corresponding
1795 /// to the field named by the designator.
1796 ///
1797 /// @param NextElementIndex If non-NULL and the first designator in @p
1798 /// DIE is an array designator or GNU array-range designator, this
1799 /// will be set to the last index initialized by this designator.
1800 ///
1801 /// @param Index Index into @p IList where the designated initializer
1802 /// @p DIE occurs.
1803 ///
1804 /// @param StructuredList The initializer list expression that
1805 /// describes all of the subobject initializers in the order they'll
1806 /// actually be initialized.
1807 ///
1808 /// @returns true if there was an error, false otherwise.
1809 bool
CheckDesignatedInitializer(const InitializedEntity & Entity,InitListExpr * IList,DesignatedInitExpr * DIE,unsigned DesigIdx,QualType & CurrentObjectType,RecordDecl::field_iterator * NextField,llvm::APSInt * NextElementIndex,unsigned & Index,InitListExpr * StructuredList,unsigned & StructuredIndex,bool FinishSubobjectInit,bool TopLevelObject)1810 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
1811 InitListExpr *IList,
1812 DesignatedInitExpr *DIE,
1813 unsigned DesigIdx,
1814 QualType &CurrentObjectType,
1815 RecordDecl::field_iterator *NextField,
1816 llvm::APSInt *NextElementIndex,
1817 unsigned &Index,
1818 InitListExpr *StructuredList,
1819 unsigned &StructuredIndex,
1820 bool FinishSubobjectInit,
1821 bool TopLevelObject) {
1822 if (DesigIdx == DIE->size()) {
1823 // Check the actual initialization for the designated object type.
1824 bool prevHadError = hadError;
1825
1826 // Temporarily remove the designator expression from the
1827 // initializer list that the child calls see, so that we don't try
1828 // to re-process the designator.
1829 unsigned OldIndex = Index;
1830 IList->setInit(OldIndex, DIE->getInit());
1831
1832 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
1833 StructuredList, StructuredIndex);
1834
1835 // Restore the designated initializer expression in the syntactic
1836 // form of the initializer list.
1837 if (IList->getInit(OldIndex) != DIE->getInit())
1838 DIE->setInit(IList->getInit(OldIndex));
1839 IList->setInit(OldIndex, DIE);
1840
1841 return hadError && !prevHadError;
1842 }
1843
1844 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
1845 bool IsFirstDesignator = (DesigIdx == 0);
1846 if (!VerifyOnly) {
1847 assert((IsFirstDesignator || StructuredList) &&
1848 "Need a non-designated initializer list to start from");
1849
1850 // Determine the structural initializer list that corresponds to the
1851 // current subobject.
1852 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
1853 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1854 StructuredList, StructuredIndex,
1855 SourceRange(D->getLocStart(),
1856 DIE->getLocEnd()));
1857 assert(StructuredList && "Expected a structured initializer list");
1858 }
1859
1860 if (D->isFieldDesignator()) {
1861 // C99 6.7.8p7:
1862 //
1863 // If a designator has the form
1864 //
1865 // . identifier
1866 //
1867 // then the current object (defined below) shall have
1868 // structure or union type and the identifier shall be the
1869 // name of a member of that type.
1870 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
1871 if (!RT) {
1872 SourceLocation Loc = D->getDotLoc();
1873 if (Loc.isInvalid())
1874 Loc = D->getFieldLoc();
1875 if (!VerifyOnly)
1876 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
1877 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
1878 ++Index;
1879 return true;
1880 }
1881
1882 FieldDecl *KnownField = D->getField();
1883 if (!KnownField) {
1884 IdentifierInfo *FieldName = D->getFieldName();
1885 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
1886 for (NamedDecl *ND : Lookup) {
1887 if (auto *FD = dyn_cast<FieldDecl>(ND)) {
1888 KnownField = FD;
1889 break;
1890 }
1891 if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
1892 // In verify mode, don't modify the original.
1893 if (VerifyOnly)
1894 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
1895 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
1896 D = DIE->getDesignator(DesigIdx);
1897 KnownField = cast<FieldDecl>(*IFD->chain_begin());
1898 break;
1899 }
1900 }
1901 if (!KnownField) {
1902 if (VerifyOnly) {
1903 ++Index;
1904 return true; // No typo correction when just trying this out.
1905 }
1906
1907 // Name lookup found something, but it wasn't a field.
1908 if (!Lookup.empty()) {
1909 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
1910 << FieldName;
1911 SemaRef.Diag(Lookup.front()->getLocation(),
1912 diag::note_field_designator_found);
1913 ++Index;
1914 return true;
1915 }
1916
1917 // Name lookup didn't find anything.
1918 // Determine whether this was a typo for another field name.
1919 if (TypoCorrection Corrected = SemaRef.CorrectTypo(
1920 DeclarationNameInfo(FieldName, D->getFieldLoc()),
1921 Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
1922 llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
1923 Sema::CTK_ErrorRecovery, RT->getDecl())) {
1924 SemaRef.diagnoseTypo(
1925 Corrected,
1926 SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
1927 << FieldName << CurrentObjectType);
1928 KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
1929 hadError = true;
1930 } else {
1931 // Typo correction didn't find anything.
1932 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1933 << FieldName << CurrentObjectType;
1934 ++Index;
1935 return true;
1936 }
1937 }
1938 }
1939
1940 unsigned FieldIndex = 0;
1941 for (auto *FI : RT->getDecl()->fields()) {
1942 if (FI->isUnnamedBitfield())
1943 continue;
1944 if (KnownField == FI)
1945 break;
1946 ++FieldIndex;
1947 }
1948
1949 RecordDecl::field_iterator Field =
1950 RecordDecl::field_iterator(DeclContext::decl_iterator(KnownField));
1951
1952 // All of the fields of a union are located at the same place in
1953 // the initializer list.
1954 if (RT->getDecl()->isUnion()) {
1955 FieldIndex = 0;
1956 if (!VerifyOnly) {
1957 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
1958 if (CurrentField && CurrentField != *Field) {
1959 assert(StructuredList->getNumInits() == 1
1960 && "A union should never have more than one initializer!");
1961
1962 // we're about to throw away an initializer, emit warning
1963 SemaRef.Diag(D->getFieldLoc(),
1964 diag::warn_initializer_overrides)
1965 << D->getSourceRange();
1966 Expr *ExistingInit = StructuredList->getInit(0);
1967 SemaRef.Diag(ExistingInit->getLocStart(),
1968 diag::note_previous_initializer)
1969 << /*FIXME:has side effects=*/0
1970 << ExistingInit->getSourceRange();
1971
1972 // remove existing initializer
1973 StructuredList->resizeInits(SemaRef.Context, 0);
1974 StructuredList->setInitializedFieldInUnion(nullptr);
1975 }
1976
1977 StructuredList->setInitializedFieldInUnion(*Field);
1978 }
1979 }
1980
1981 // Make sure we can use this declaration.
1982 bool InvalidUse;
1983 if (VerifyOnly)
1984 InvalidUse = !SemaRef.CanUseDecl(*Field);
1985 else
1986 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
1987 if (InvalidUse) {
1988 ++Index;
1989 return true;
1990 }
1991
1992 if (!VerifyOnly) {
1993 // Update the designator with the field declaration.
1994 D->setField(*Field);
1995
1996 // Make sure that our non-designated initializer list has space
1997 // for a subobject corresponding to this field.
1998 if (FieldIndex >= StructuredList->getNumInits())
1999 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2000 }
2001
2002 // This designator names a flexible array member.
2003 if (Field->getType()->isIncompleteArrayType()) {
2004 bool Invalid = false;
2005 if ((DesigIdx + 1) != DIE->size()) {
2006 // We can't designate an object within the flexible array
2007 // member (because GCC doesn't allow it).
2008 if (!VerifyOnly) {
2009 DesignatedInitExpr::Designator *NextD
2010 = DIE->getDesignator(DesigIdx + 1);
2011 SemaRef.Diag(NextD->getLocStart(),
2012 diag::err_designator_into_flexible_array_member)
2013 << SourceRange(NextD->getLocStart(),
2014 DIE->getLocEnd());
2015 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2016 << *Field;
2017 }
2018 Invalid = true;
2019 }
2020
2021 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2022 !isa<StringLiteral>(DIE->getInit())) {
2023 // The initializer is not an initializer list.
2024 if (!VerifyOnly) {
2025 SemaRef.Diag(DIE->getInit()->getLocStart(),
2026 diag::err_flexible_array_init_needs_braces)
2027 << DIE->getInit()->getSourceRange();
2028 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2029 << *Field;
2030 }
2031 Invalid = true;
2032 }
2033
2034 // Check GNU flexible array initializer.
2035 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2036 TopLevelObject))
2037 Invalid = true;
2038
2039 if (Invalid) {
2040 ++Index;
2041 return true;
2042 }
2043
2044 // Initialize the array.
2045 bool prevHadError = hadError;
2046 unsigned newStructuredIndex = FieldIndex;
2047 unsigned OldIndex = Index;
2048 IList->setInit(Index, DIE->getInit());
2049
2050 InitializedEntity MemberEntity =
2051 InitializedEntity::InitializeMember(*Field, &Entity);
2052 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2053 StructuredList, newStructuredIndex);
2054
2055 IList->setInit(OldIndex, DIE);
2056 if (hadError && !prevHadError) {
2057 ++Field;
2058 ++FieldIndex;
2059 if (NextField)
2060 *NextField = Field;
2061 StructuredIndex = FieldIndex;
2062 return true;
2063 }
2064 } else {
2065 // Recurse to check later designated subobjects.
2066 QualType FieldType = Field->getType();
2067 unsigned newStructuredIndex = FieldIndex;
2068
2069 InitializedEntity MemberEntity =
2070 InitializedEntity::InitializeMember(*Field, &Entity);
2071 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2072 FieldType, nullptr, nullptr, Index,
2073 StructuredList, newStructuredIndex,
2074 true, false))
2075 return true;
2076 }
2077
2078 // Find the position of the next field to be initialized in this
2079 // subobject.
2080 ++Field;
2081 ++FieldIndex;
2082
2083 // If this the first designator, our caller will continue checking
2084 // the rest of this struct/class/union subobject.
2085 if (IsFirstDesignator) {
2086 if (NextField)
2087 *NextField = Field;
2088 StructuredIndex = FieldIndex;
2089 return false;
2090 }
2091
2092 if (!FinishSubobjectInit)
2093 return false;
2094
2095 // We've already initialized something in the union; we're done.
2096 if (RT->getDecl()->isUnion())
2097 return hadError;
2098
2099 // Check the remaining fields within this class/struct/union subobject.
2100 bool prevHadError = hadError;
2101
2102 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
2103 StructuredList, FieldIndex);
2104 return hadError && !prevHadError;
2105 }
2106
2107 // C99 6.7.8p6:
2108 //
2109 // If a designator has the form
2110 //
2111 // [ constant-expression ]
2112 //
2113 // then the current object (defined below) shall have array
2114 // type and the expression shall be an integer constant
2115 // expression. If the array is of unknown size, any
2116 // nonnegative value is valid.
2117 //
2118 // Additionally, cope with the GNU extension that permits
2119 // designators of the form
2120 //
2121 // [ constant-expression ... constant-expression ]
2122 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2123 if (!AT) {
2124 if (!VerifyOnly)
2125 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2126 << CurrentObjectType;
2127 ++Index;
2128 return true;
2129 }
2130
2131 Expr *IndexExpr = nullptr;
2132 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2133 if (D->isArrayDesignator()) {
2134 IndexExpr = DIE->getArrayIndex(*D);
2135 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2136 DesignatedEndIndex = DesignatedStartIndex;
2137 } else {
2138 assert(D->isArrayRangeDesignator() && "Need array-range designator");
2139
2140 DesignatedStartIndex =
2141 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
2142 DesignatedEndIndex =
2143 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2144 IndexExpr = DIE->getArrayRangeEnd(*D);
2145
2146 // Codegen can't handle evaluating array range designators that have side
2147 // effects, because we replicate the AST value for each initialized element.
2148 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2149 // elements with something that has a side effect, so codegen can emit an
2150 // "error unsupported" error instead of miscompiling the app.
2151 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2152 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2153 FullyStructuredList->sawArrayRangeDesignator();
2154 }
2155
2156 if (isa<ConstantArrayType>(AT)) {
2157 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2158 DesignatedStartIndex
2159 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2160 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2161 DesignatedEndIndex
2162 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2163 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2164 if (DesignatedEndIndex >= MaxElements) {
2165 if (!VerifyOnly)
2166 SemaRef.Diag(IndexExpr->getLocStart(),
2167 diag::err_array_designator_too_large)
2168 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2169 << IndexExpr->getSourceRange();
2170 ++Index;
2171 return true;
2172 }
2173 } else {
2174 // Make sure the bit-widths and signedness match.
2175 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
2176 DesignatedEndIndex
2177 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
2178 else if (DesignatedStartIndex.getBitWidth() <
2179 DesignatedEndIndex.getBitWidth())
2180 DesignatedStartIndex
2181 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
2182 DesignatedStartIndex.setIsUnsigned(true);
2183 DesignatedEndIndex.setIsUnsigned(true);
2184 }
2185
2186 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2187 // We're modifying a string literal init; we have to decompose the string
2188 // so we can modify the individual characters.
2189 ASTContext &Context = SemaRef.Context;
2190 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2191
2192 // Compute the character type
2193 QualType CharTy = AT->getElementType();
2194
2195 // Compute the type of the integer literals.
2196 QualType PromotedCharTy = CharTy;
2197 if (CharTy->isPromotableIntegerType())
2198 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2199 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2200
2201 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2202 // Get the length of the string.
2203 uint64_t StrLen = SL->getLength();
2204 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2205 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2206 StructuredList->resizeInits(Context, StrLen);
2207
2208 // Build a literal for each character in the string, and put them into
2209 // the init list.
2210 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2211 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2212 Expr *Init = new (Context) IntegerLiteral(
2213 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2214 if (CharTy != PromotedCharTy)
2215 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2216 Init, nullptr, VK_RValue);
2217 StructuredList->updateInit(Context, i, Init);
2218 }
2219 } else {
2220 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2221 std::string Str;
2222 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2223
2224 // Get the length of the string.
2225 uint64_t StrLen = Str.size();
2226 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2227 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2228 StructuredList->resizeInits(Context, StrLen);
2229
2230 // Build a literal for each character in the string, and put them into
2231 // the init list.
2232 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2233 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2234 Expr *Init = new (Context) IntegerLiteral(
2235 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2236 if (CharTy != PromotedCharTy)
2237 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2238 Init, nullptr, VK_RValue);
2239 StructuredList->updateInit(Context, i, Init);
2240 }
2241 }
2242 }
2243
2244 // Make sure that our non-designated initializer list has space
2245 // for a subobject corresponding to this array element.
2246 if (!VerifyOnly &&
2247 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2248 StructuredList->resizeInits(SemaRef.Context,
2249 DesignatedEndIndex.getZExtValue() + 1);
2250
2251 // Repeatedly perform subobject initializations in the range
2252 // [DesignatedStartIndex, DesignatedEndIndex].
2253
2254 // Move to the next designator
2255 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2256 unsigned OldIndex = Index;
2257
2258 InitializedEntity ElementEntity =
2259 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2260
2261 while (DesignatedStartIndex <= DesignatedEndIndex) {
2262 // Recurse to check later designated subobjects.
2263 QualType ElementType = AT->getElementType();
2264 Index = OldIndex;
2265
2266 ElementEntity.setElementIndex(ElementIndex);
2267 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2268 ElementType, nullptr, nullptr, Index,
2269 StructuredList, ElementIndex,
2270 (DesignatedStartIndex == DesignatedEndIndex),
2271 false))
2272 return true;
2273
2274 // Move to the next index in the array that we'll be initializing.
2275 ++DesignatedStartIndex;
2276 ElementIndex = DesignatedStartIndex.getZExtValue();
2277 }
2278
2279 // If this the first designator, our caller will continue checking
2280 // the rest of this array subobject.
2281 if (IsFirstDesignator) {
2282 if (NextElementIndex)
2283 *NextElementIndex = DesignatedStartIndex;
2284 StructuredIndex = ElementIndex;
2285 return false;
2286 }
2287
2288 if (!FinishSubobjectInit)
2289 return false;
2290
2291 // Check the remaining elements within this array subobject.
2292 bool prevHadError = hadError;
2293 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2294 /*SubobjectIsDesignatorContext=*/false, Index,
2295 StructuredList, ElementIndex);
2296 return hadError && !prevHadError;
2297 }
2298
2299 // Get the structured initializer list for a subobject of type
2300 // @p CurrentObjectType.
2301 InitListExpr *
getStructuredSubobjectInit(InitListExpr * IList,unsigned Index,QualType CurrentObjectType,InitListExpr * StructuredList,unsigned StructuredIndex,SourceRange InitRange)2302 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2303 QualType CurrentObjectType,
2304 InitListExpr *StructuredList,
2305 unsigned StructuredIndex,
2306 SourceRange InitRange) {
2307 if (VerifyOnly)
2308 return nullptr; // No structured list in verification-only mode.
2309 Expr *ExistingInit = nullptr;
2310 if (!StructuredList)
2311 ExistingInit = SyntacticToSemantic.lookup(IList);
2312 else if (StructuredIndex < StructuredList->getNumInits())
2313 ExistingInit = StructuredList->getInit(StructuredIndex);
2314
2315 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2316 return Result;
2317
2318 if (ExistingInit) {
2319 // We are creating an initializer list that initializes the
2320 // subobjects of the current object, but there was already an
2321 // initialization that completely initialized the current
2322 // subobject, e.g., by a compound literal:
2323 //
2324 // struct X { int a, b; };
2325 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2326 //
2327 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2328 // designated initializer re-initializes the whole
2329 // subobject [0], overwriting previous initializers.
2330 SemaRef.Diag(InitRange.getBegin(),
2331 diag::warn_subobject_initializer_overrides)
2332 << InitRange;
2333 SemaRef.Diag(ExistingInit->getLocStart(),
2334 diag::note_previous_initializer)
2335 << /*FIXME:has side effects=*/0
2336 << ExistingInit->getSourceRange();
2337 }
2338
2339 InitListExpr *Result
2340 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2341 InitRange.getBegin(), None,
2342 InitRange.getEnd());
2343
2344 QualType ResultType = CurrentObjectType;
2345 if (!ResultType->isArrayType())
2346 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2347 Result->setType(ResultType);
2348
2349 // Pre-allocate storage for the structured initializer list.
2350 unsigned NumElements = 0;
2351 unsigned NumInits = 0;
2352 bool GotNumInits = false;
2353 if (!StructuredList) {
2354 NumInits = IList->getNumInits();
2355 GotNumInits = true;
2356 } else if (Index < IList->getNumInits()) {
2357 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2358 NumInits = SubList->getNumInits();
2359 GotNumInits = true;
2360 }
2361 }
2362
2363 if (const ArrayType *AType
2364 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2365 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2366 NumElements = CAType->getSize().getZExtValue();
2367 // Simple heuristic so that we don't allocate a very large
2368 // initializer with many empty entries at the end.
2369 if (GotNumInits && NumElements > NumInits)
2370 NumElements = 0;
2371 }
2372 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2373 NumElements = VType->getNumElements();
2374 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2375 RecordDecl *RDecl = RType->getDecl();
2376 if (RDecl->isUnion())
2377 NumElements = 1;
2378 else
2379 NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2380 }
2381
2382 Result->reserveInits(SemaRef.Context, NumElements);
2383
2384 // Link this new initializer list into the structured initializer
2385 // lists.
2386 if (StructuredList)
2387 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2388 else {
2389 Result->setSyntacticForm(IList);
2390 SyntacticToSemantic[IList] = Result;
2391 }
2392
2393 return Result;
2394 }
2395
2396 /// Update the initializer at index @p StructuredIndex within the
2397 /// structured initializer list to the value @p expr.
UpdateStructuredListElement(InitListExpr * StructuredList,unsigned & StructuredIndex,Expr * expr)2398 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2399 unsigned &StructuredIndex,
2400 Expr *expr) {
2401 // No structured initializer list to update
2402 if (!StructuredList)
2403 return;
2404
2405 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2406 StructuredIndex, expr)) {
2407 // This initializer overwrites a previous initializer. Warn.
2408 SemaRef.Diag(expr->getLocStart(),
2409 diag::warn_initializer_overrides)
2410 << expr->getSourceRange();
2411 SemaRef.Diag(PrevInit->getLocStart(),
2412 diag::note_previous_initializer)
2413 << /*FIXME:has side effects=*/0
2414 << PrevInit->getSourceRange();
2415 }
2416
2417 ++StructuredIndex;
2418 }
2419
2420 /// Check that the given Index expression is a valid array designator
2421 /// value. This is essentially just a wrapper around
2422 /// VerifyIntegerConstantExpression that also checks for negative values
2423 /// and produces a reasonable diagnostic if there is a
2424 /// failure. Returns the index expression, possibly with an implicit cast
2425 /// added, on success. If everything went okay, Value will receive the
2426 /// value of the constant expression.
2427 static ExprResult
CheckArrayDesignatorExpr(Sema & S,Expr * Index,llvm::APSInt & Value)2428 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2429 SourceLocation Loc = Index->getLocStart();
2430
2431 // Make sure this is an integer constant expression.
2432 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2433 if (Result.isInvalid())
2434 return Result;
2435
2436 if (Value.isSigned() && Value.isNegative())
2437 return S.Diag(Loc, diag::err_array_designator_negative)
2438 << Value.toString(10) << Index->getSourceRange();
2439
2440 Value.setIsUnsigned(true);
2441 return Result;
2442 }
2443
ActOnDesignatedInitializer(Designation & Desig,SourceLocation Loc,bool GNUSyntax,ExprResult Init)2444 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2445 SourceLocation Loc,
2446 bool GNUSyntax,
2447 ExprResult Init) {
2448 typedef DesignatedInitExpr::Designator ASTDesignator;
2449
2450 bool Invalid = false;
2451 SmallVector<ASTDesignator, 32> Designators;
2452 SmallVector<Expr *, 32> InitExpressions;
2453
2454 // Build designators and check array designator expressions.
2455 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2456 const Designator &D = Desig.getDesignator(Idx);
2457 switch (D.getKind()) {
2458 case Designator::FieldDesignator:
2459 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2460 D.getFieldLoc()));
2461 break;
2462
2463 case Designator::ArrayDesignator: {
2464 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2465 llvm::APSInt IndexValue;
2466 if (!Index->isTypeDependent() && !Index->isValueDependent())
2467 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2468 if (!Index)
2469 Invalid = true;
2470 else {
2471 Designators.push_back(ASTDesignator(InitExpressions.size(),
2472 D.getLBracketLoc(),
2473 D.getRBracketLoc()));
2474 InitExpressions.push_back(Index);
2475 }
2476 break;
2477 }
2478
2479 case Designator::ArrayRangeDesignator: {
2480 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2481 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2482 llvm::APSInt StartValue;
2483 llvm::APSInt EndValue;
2484 bool StartDependent = StartIndex->isTypeDependent() ||
2485 StartIndex->isValueDependent();
2486 bool EndDependent = EndIndex->isTypeDependent() ||
2487 EndIndex->isValueDependent();
2488 if (!StartDependent)
2489 StartIndex =
2490 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2491 if (!EndDependent)
2492 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2493
2494 if (!StartIndex || !EndIndex)
2495 Invalid = true;
2496 else {
2497 // Make sure we're comparing values with the same bit width.
2498 if (StartDependent || EndDependent) {
2499 // Nothing to compute.
2500 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2501 EndValue = EndValue.extend(StartValue.getBitWidth());
2502 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2503 StartValue = StartValue.extend(EndValue.getBitWidth());
2504
2505 if (!StartDependent && !EndDependent && EndValue < StartValue) {
2506 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2507 << StartValue.toString(10) << EndValue.toString(10)
2508 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2509 Invalid = true;
2510 } else {
2511 Designators.push_back(ASTDesignator(InitExpressions.size(),
2512 D.getLBracketLoc(),
2513 D.getEllipsisLoc(),
2514 D.getRBracketLoc()));
2515 InitExpressions.push_back(StartIndex);
2516 InitExpressions.push_back(EndIndex);
2517 }
2518 }
2519 break;
2520 }
2521 }
2522 }
2523
2524 if (Invalid || Init.isInvalid())
2525 return ExprError();
2526
2527 // Clear out the expressions within the designation.
2528 Desig.ClearExprs(*this);
2529
2530 DesignatedInitExpr *DIE
2531 = DesignatedInitExpr::Create(Context,
2532 Designators.data(), Designators.size(),
2533 InitExpressions, Loc, GNUSyntax,
2534 Init.getAs<Expr>());
2535
2536 if (!getLangOpts().C99)
2537 Diag(DIE->getLocStart(), diag::ext_designated_init)
2538 << DIE->getSourceRange();
2539
2540 return DIE;
2541 }
2542
2543 //===----------------------------------------------------------------------===//
2544 // Initialization entity
2545 //===----------------------------------------------------------------------===//
2546
InitializedEntity(ASTContext & Context,unsigned Index,const InitializedEntity & Parent)2547 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2548 const InitializedEntity &Parent)
2549 : Parent(&Parent), Index(Index)
2550 {
2551 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2552 Kind = EK_ArrayElement;
2553 Type = AT->getElementType();
2554 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2555 Kind = EK_VectorElement;
2556 Type = VT->getElementType();
2557 } else {
2558 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2559 assert(CT && "Unexpected type");
2560 Kind = EK_ComplexElement;
2561 Type = CT->getElementType();
2562 }
2563 }
2564
2565 InitializedEntity
InitializeBase(ASTContext & Context,const CXXBaseSpecifier * Base,bool IsInheritedVirtualBase)2566 InitializedEntity::InitializeBase(ASTContext &Context,
2567 const CXXBaseSpecifier *Base,
2568 bool IsInheritedVirtualBase) {
2569 InitializedEntity Result;
2570 Result.Kind = EK_Base;
2571 Result.Parent = nullptr;
2572 Result.Base = reinterpret_cast<uintptr_t>(Base);
2573 if (IsInheritedVirtualBase)
2574 Result.Base |= 0x01;
2575
2576 Result.Type = Base->getType();
2577 return Result;
2578 }
2579
getName() const2580 DeclarationName InitializedEntity::getName() const {
2581 switch (getKind()) {
2582 case EK_Parameter:
2583 case EK_Parameter_CF_Audited: {
2584 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2585 return (D ? D->getDeclName() : DeclarationName());
2586 }
2587
2588 case EK_Variable:
2589 case EK_Member:
2590 return VariableOrMember->getDeclName();
2591
2592 case EK_LambdaCapture:
2593 return DeclarationName(Capture.VarID);
2594
2595 case EK_Result:
2596 case EK_Exception:
2597 case EK_New:
2598 case EK_Temporary:
2599 case EK_Base:
2600 case EK_Delegating:
2601 case EK_ArrayElement:
2602 case EK_VectorElement:
2603 case EK_ComplexElement:
2604 case EK_BlockElement:
2605 case EK_CompoundLiteralInit:
2606 case EK_RelatedResult:
2607 return DeclarationName();
2608 }
2609
2610 llvm_unreachable("Invalid EntityKind!");
2611 }
2612
getDecl() const2613 DeclaratorDecl *InitializedEntity::getDecl() const {
2614 switch (getKind()) {
2615 case EK_Variable:
2616 case EK_Member:
2617 return VariableOrMember;
2618
2619 case EK_Parameter:
2620 case EK_Parameter_CF_Audited:
2621 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2622
2623 case EK_Result:
2624 case EK_Exception:
2625 case EK_New:
2626 case EK_Temporary:
2627 case EK_Base:
2628 case EK_Delegating:
2629 case EK_ArrayElement:
2630 case EK_VectorElement:
2631 case EK_ComplexElement:
2632 case EK_BlockElement:
2633 case EK_LambdaCapture:
2634 case EK_CompoundLiteralInit:
2635 case EK_RelatedResult:
2636 return nullptr;
2637 }
2638
2639 llvm_unreachable("Invalid EntityKind!");
2640 }
2641
allowsNRVO() const2642 bool InitializedEntity::allowsNRVO() const {
2643 switch (getKind()) {
2644 case EK_Result:
2645 case EK_Exception:
2646 return LocAndNRVO.NRVO;
2647
2648 case EK_Variable:
2649 case EK_Parameter:
2650 case EK_Parameter_CF_Audited:
2651 case EK_Member:
2652 case EK_New:
2653 case EK_Temporary:
2654 case EK_CompoundLiteralInit:
2655 case EK_Base:
2656 case EK_Delegating:
2657 case EK_ArrayElement:
2658 case EK_VectorElement:
2659 case EK_ComplexElement:
2660 case EK_BlockElement:
2661 case EK_LambdaCapture:
2662 case EK_RelatedResult:
2663 break;
2664 }
2665
2666 return false;
2667 }
2668
dumpImpl(raw_ostream & OS) const2669 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2670 assert(getParent() != this);
2671 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2672 for (unsigned I = 0; I != Depth; ++I)
2673 OS << "`-";
2674
2675 switch (getKind()) {
2676 case EK_Variable: OS << "Variable"; break;
2677 case EK_Parameter: OS << "Parameter"; break;
2678 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2679 break;
2680 case EK_Result: OS << "Result"; break;
2681 case EK_Exception: OS << "Exception"; break;
2682 case EK_Member: OS << "Member"; break;
2683 case EK_New: OS << "New"; break;
2684 case EK_Temporary: OS << "Temporary"; break;
2685 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2686 case EK_RelatedResult: OS << "RelatedResult"; break;
2687 case EK_Base: OS << "Base"; break;
2688 case EK_Delegating: OS << "Delegating"; break;
2689 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2690 case EK_VectorElement: OS << "VectorElement " << Index; break;
2691 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2692 case EK_BlockElement: OS << "Block"; break;
2693 case EK_LambdaCapture:
2694 OS << "LambdaCapture ";
2695 OS << DeclarationName(Capture.VarID);
2696 break;
2697 }
2698
2699 if (Decl *D = getDecl()) {
2700 OS << " ";
2701 cast<NamedDecl>(D)->printQualifiedName(OS);
2702 }
2703
2704 OS << " '" << getType().getAsString() << "'\n";
2705
2706 return Depth + 1;
2707 }
2708
dump() const2709 void InitializedEntity::dump() const {
2710 dumpImpl(llvm::errs());
2711 }
2712
2713 //===----------------------------------------------------------------------===//
2714 // Initialization sequence
2715 //===----------------------------------------------------------------------===//
2716
Destroy()2717 void InitializationSequence::Step::Destroy() {
2718 switch (Kind) {
2719 case SK_ResolveAddressOfOverloadedFunction:
2720 case SK_CastDerivedToBaseRValue:
2721 case SK_CastDerivedToBaseXValue:
2722 case SK_CastDerivedToBaseLValue:
2723 case SK_BindReference:
2724 case SK_BindReferenceToTemporary:
2725 case SK_ExtraneousCopyToTemporary:
2726 case SK_UserConversion:
2727 case SK_QualificationConversionRValue:
2728 case SK_QualificationConversionXValue:
2729 case SK_QualificationConversionLValue:
2730 case SK_AtomicConversion:
2731 case SK_LValueToRValue:
2732 case SK_ListInitialization:
2733 case SK_UnwrapInitList:
2734 case SK_RewrapInitList:
2735 case SK_ConstructorInitialization:
2736 case SK_ConstructorInitializationFromList:
2737 case SK_ZeroInitialization:
2738 case SK_CAssignment:
2739 case SK_StringInit:
2740 case SK_ObjCObjectConversion:
2741 case SK_ArrayInit:
2742 case SK_ParenthesizedArrayInit:
2743 case SK_PassByIndirectCopyRestore:
2744 case SK_PassByIndirectRestore:
2745 case SK_ProduceObjCObject:
2746 case SK_StdInitializerList:
2747 case SK_StdInitializerListConstructorCall:
2748 case SK_OCLSamplerInit:
2749 case SK_OCLZeroEvent:
2750 break;
2751
2752 case SK_ConversionSequence:
2753 case SK_ConversionSequenceNoNarrowing:
2754 delete ICS;
2755 }
2756 }
2757
isDirectReferenceBinding() const2758 bool InitializationSequence::isDirectReferenceBinding() const {
2759 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
2760 }
2761
isAmbiguous() const2762 bool InitializationSequence::isAmbiguous() const {
2763 if (!Failed())
2764 return false;
2765
2766 switch (getFailureKind()) {
2767 case FK_TooManyInitsForReference:
2768 case FK_ArrayNeedsInitList:
2769 case FK_ArrayNeedsInitListOrStringLiteral:
2770 case FK_ArrayNeedsInitListOrWideStringLiteral:
2771 case FK_NarrowStringIntoWideCharArray:
2772 case FK_WideStringIntoCharArray:
2773 case FK_IncompatWideStringIntoWideChar:
2774 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2775 case FK_NonConstLValueReferenceBindingToTemporary:
2776 case FK_NonConstLValueReferenceBindingToUnrelated:
2777 case FK_RValueReferenceBindingToLValue:
2778 case FK_ReferenceInitDropsQualifiers:
2779 case FK_ReferenceInitFailed:
2780 case FK_ConversionFailed:
2781 case FK_ConversionFromPropertyFailed:
2782 case FK_TooManyInitsForScalar:
2783 case FK_ReferenceBindingToInitList:
2784 case FK_InitListBadDestinationType:
2785 case FK_DefaultInitOfConst:
2786 case FK_Incomplete:
2787 case FK_ArrayTypeMismatch:
2788 case FK_NonConstantArrayInit:
2789 case FK_ListInitializationFailed:
2790 case FK_VariableLengthArrayHasInitializer:
2791 case FK_PlaceholderType:
2792 case FK_ExplicitConstructor:
2793 return false;
2794
2795 case FK_ReferenceInitOverloadFailed:
2796 case FK_UserConversionOverloadFailed:
2797 case FK_ConstructorOverloadFailed:
2798 case FK_ListConstructorOverloadFailed:
2799 return FailedOverloadResult == OR_Ambiguous;
2800 }
2801
2802 llvm_unreachable("Invalid EntityKind!");
2803 }
2804
isConstructorInitialization() const2805 bool InitializationSequence::isConstructorInitialization() const {
2806 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2807 }
2808
2809 void
2810 InitializationSequence
AddAddressOverloadResolutionStep(FunctionDecl * Function,DeclAccessPair Found,bool HadMultipleCandidates)2811 ::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2812 DeclAccessPair Found,
2813 bool HadMultipleCandidates) {
2814 Step S;
2815 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2816 S.Type = Function->getType();
2817 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2818 S.Function.Function = Function;
2819 S.Function.FoundDecl = Found;
2820 Steps.push_back(S);
2821 }
2822
AddDerivedToBaseCastStep(QualType BaseType,ExprValueKind VK)2823 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
2824 ExprValueKind VK) {
2825 Step S;
2826 switch (VK) {
2827 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2828 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2829 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
2830 }
2831 S.Type = BaseType;
2832 Steps.push_back(S);
2833 }
2834
AddReferenceBindingStep(QualType T,bool BindingTemporary)2835 void InitializationSequence::AddReferenceBindingStep(QualType T,
2836 bool BindingTemporary) {
2837 Step S;
2838 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2839 S.Type = T;
2840 Steps.push_back(S);
2841 }
2842
AddExtraneousCopyToTemporary(QualType T)2843 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2844 Step S;
2845 S.Kind = SK_ExtraneousCopyToTemporary;
2846 S.Type = T;
2847 Steps.push_back(S);
2848 }
2849
2850 void
AddUserConversionStep(FunctionDecl * Function,DeclAccessPair FoundDecl,QualType T,bool HadMultipleCandidates)2851 InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2852 DeclAccessPair FoundDecl,
2853 QualType T,
2854 bool HadMultipleCandidates) {
2855 Step S;
2856 S.Kind = SK_UserConversion;
2857 S.Type = T;
2858 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2859 S.Function.Function = Function;
2860 S.Function.FoundDecl = FoundDecl;
2861 Steps.push_back(S);
2862 }
2863
AddQualificationConversionStep(QualType Ty,ExprValueKind VK)2864 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
2865 ExprValueKind VK) {
2866 Step S;
2867 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
2868 switch (VK) {
2869 case VK_RValue:
2870 S.Kind = SK_QualificationConversionRValue;
2871 break;
2872 case VK_XValue:
2873 S.Kind = SK_QualificationConversionXValue;
2874 break;
2875 case VK_LValue:
2876 S.Kind = SK_QualificationConversionLValue;
2877 break;
2878 }
2879 S.Type = Ty;
2880 Steps.push_back(S);
2881 }
2882
AddAtomicConversionStep(QualType Ty)2883 void InitializationSequence::AddAtomicConversionStep(QualType Ty) {
2884 Step S;
2885 S.Kind = SK_AtomicConversion;
2886 S.Type = Ty;
2887 Steps.push_back(S);
2888 }
2889
AddLValueToRValueStep(QualType Ty)2890 void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
2891 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
2892
2893 Step S;
2894 S.Kind = SK_LValueToRValue;
2895 S.Type = Ty;
2896 Steps.push_back(S);
2897 }
2898
AddConversionSequenceStep(const ImplicitConversionSequence & ICS,QualType T,bool TopLevelOfInitList)2899 void InitializationSequence::AddConversionSequenceStep(
2900 const ImplicitConversionSequence &ICS, QualType T,
2901 bool TopLevelOfInitList) {
2902 Step S;
2903 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
2904 : SK_ConversionSequence;
2905 S.Type = T;
2906 S.ICS = new ImplicitConversionSequence(ICS);
2907 Steps.push_back(S);
2908 }
2909
AddListInitializationStep(QualType T)2910 void InitializationSequence::AddListInitializationStep(QualType T) {
2911 Step S;
2912 S.Kind = SK_ListInitialization;
2913 S.Type = T;
2914 Steps.push_back(S);
2915 }
2916
2917 void
2918 InitializationSequence
AddConstructorInitializationStep(CXXConstructorDecl * Constructor,AccessSpecifier Access,QualType T,bool HadMultipleCandidates,bool FromInitList,bool AsInitList)2919 ::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2920 AccessSpecifier Access,
2921 QualType T,
2922 bool HadMultipleCandidates,
2923 bool FromInitList, bool AsInitList) {
2924 Step S;
2925 S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
2926 : SK_ConstructorInitializationFromList
2927 : SK_ConstructorInitialization;
2928 S.Type = T;
2929 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2930 S.Function.Function = Constructor;
2931 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
2932 Steps.push_back(S);
2933 }
2934
AddZeroInitializationStep(QualType T)2935 void InitializationSequence::AddZeroInitializationStep(QualType T) {
2936 Step S;
2937 S.Kind = SK_ZeroInitialization;
2938 S.Type = T;
2939 Steps.push_back(S);
2940 }
2941
AddCAssignmentStep(QualType T)2942 void InitializationSequence::AddCAssignmentStep(QualType T) {
2943 Step S;
2944 S.Kind = SK_CAssignment;
2945 S.Type = T;
2946 Steps.push_back(S);
2947 }
2948
AddStringInitStep(QualType T)2949 void InitializationSequence::AddStringInitStep(QualType T) {
2950 Step S;
2951 S.Kind = SK_StringInit;
2952 S.Type = T;
2953 Steps.push_back(S);
2954 }
2955
AddObjCObjectConversionStep(QualType T)2956 void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2957 Step S;
2958 S.Kind = SK_ObjCObjectConversion;
2959 S.Type = T;
2960 Steps.push_back(S);
2961 }
2962
AddArrayInitStep(QualType T)2963 void InitializationSequence::AddArrayInitStep(QualType T) {
2964 Step S;
2965 S.Kind = SK_ArrayInit;
2966 S.Type = T;
2967 Steps.push_back(S);
2968 }
2969
AddParenthesizedArrayInitStep(QualType T)2970 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2971 Step S;
2972 S.Kind = SK_ParenthesizedArrayInit;
2973 S.Type = T;
2974 Steps.push_back(S);
2975 }
2976
AddPassByIndirectCopyRestoreStep(QualType type,bool shouldCopy)2977 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2978 bool shouldCopy) {
2979 Step s;
2980 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2981 : SK_PassByIndirectRestore);
2982 s.Type = type;
2983 Steps.push_back(s);
2984 }
2985
AddProduceObjCObjectStep(QualType T)2986 void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2987 Step S;
2988 S.Kind = SK_ProduceObjCObject;
2989 S.Type = T;
2990 Steps.push_back(S);
2991 }
2992
AddStdInitializerListConstructionStep(QualType T)2993 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2994 Step S;
2995 S.Kind = SK_StdInitializerList;
2996 S.Type = T;
2997 Steps.push_back(S);
2998 }
2999
AddOCLSamplerInitStep(QualType T)3000 void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
3001 Step S;
3002 S.Kind = SK_OCLSamplerInit;
3003 S.Type = T;
3004 Steps.push_back(S);
3005 }
3006
AddOCLZeroEventStep(QualType T)3007 void InitializationSequence::AddOCLZeroEventStep(QualType T) {
3008 Step S;
3009 S.Kind = SK_OCLZeroEvent;
3010 S.Type = T;
3011 Steps.push_back(S);
3012 }
3013
RewrapReferenceInitList(QualType T,InitListExpr * Syntactic)3014 void InitializationSequence::RewrapReferenceInitList(QualType T,
3015 InitListExpr *Syntactic) {
3016 assert(Syntactic->getNumInits() == 1 &&
3017 "Can only rewrap trivial init lists.");
3018 Step S;
3019 S.Kind = SK_UnwrapInitList;
3020 S.Type = Syntactic->getInit(0)->getType();
3021 Steps.insert(Steps.begin(), S);
3022
3023 S.Kind = SK_RewrapInitList;
3024 S.Type = T;
3025 S.WrappingSyntacticList = Syntactic;
3026 Steps.push_back(S);
3027 }
3028
SetOverloadFailure(FailureKind Failure,OverloadingResult Result)3029 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
3030 OverloadingResult Result) {
3031 setSequenceKind(FailedSequence);
3032 this->Failure = Failure;
3033 this->FailedOverloadResult = Result;
3034 }
3035
3036 //===----------------------------------------------------------------------===//
3037 // Attempt initialization
3038 //===----------------------------------------------------------------------===//
3039
MaybeProduceObjCObject(Sema & S,InitializationSequence & Sequence,const InitializedEntity & Entity)3040 static void MaybeProduceObjCObject(Sema &S,
3041 InitializationSequence &Sequence,
3042 const InitializedEntity &Entity) {
3043 if (!S.getLangOpts().ObjCAutoRefCount) return;
3044
3045 /// When initializing a parameter, produce the value if it's marked
3046 /// __attribute__((ns_consumed)).
3047 if (Entity.isParameterKind()) {
3048 if (!Entity.isParameterConsumed())
3049 return;
3050
3051 assert(Entity.getType()->isObjCRetainableType() &&
3052 "consuming an object of unretainable type?");
3053 Sequence.AddProduceObjCObjectStep(Entity.getType());
3054
3055 /// When initializing a return value, if the return type is a
3056 /// retainable type, then returns need to immediately retain the
3057 /// object. If an autorelease is required, it will be done at the
3058 /// last instant.
3059 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3060 if (!Entity.getType()->isObjCRetainableType())
3061 return;
3062
3063 Sequence.AddProduceObjCObjectStep(Entity.getType());
3064 }
3065 }
3066
3067 static void TryListInitialization(Sema &S,
3068 const InitializedEntity &Entity,
3069 const InitializationKind &Kind,
3070 InitListExpr *InitList,
3071 InitializationSequence &Sequence);
3072
3073 /// \brief When initializing from init list via constructor, handle
3074 /// initialization of an object of type std::initializer_list<T>.
3075 ///
3076 /// \return true if we have handled initialization of an object of type
3077 /// std::initializer_list<T>, false otherwise.
TryInitializerListConstruction(Sema & S,InitListExpr * List,QualType DestType,InitializationSequence & Sequence)3078 static bool TryInitializerListConstruction(Sema &S,
3079 InitListExpr *List,
3080 QualType DestType,
3081 InitializationSequence &Sequence) {
3082 QualType E;
3083 if (!S.isStdInitializerList(DestType, &E))
3084 return false;
3085
3086 if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
3087 Sequence.setIncompleteTypeFailure(E);
3088 return true;
3089 }
3090
3091 // Try initializing a temporary array from the init list.
3092 QualType ArrayType = S.Context.getConstantArrayType(
3093 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3094 List->getNumInits()),
3095 clang::ArrayType::Normal, 0);
3096 InitializedEntity HiddenArray =
3097 InitializedEntity::InitializeTemporary(ArrayType);
3098 InitializationKind Kind =
3099 InitializationKind::CreateDirectList(List->getExprLoc());
3100 TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3101 if (Sequence)
3102 Sequence.AddStdInitializerListConstructionStep(DestType);
3103 return true;
3104 }
3105
3106 static OverloadingResult
ResolveConstructorOverload(Sema & S,SourceLocation DeclLoc,MultiExprArg Args,OverloadCandidateSet & CandidateSet,ArrayRef<NamedDecl * > Ctors,OverloadCandidateSet::iterator & Best,bool CopyInitializing,bool AllowExplicit,bool OnlyListConstructors,bool InitListSyntax)3107 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
3108 MultiExprArg Args,
3109 OverloadCandidateSet &CandidateSet,
3110 ArrayRef<NamedDecl *> Ctors,
3111 OverloadCandidateSet::iterator &Best,
3112 bool CopyInitializing, bool AllowExplicit,
3113 bool OnlyListConstructors, bool InitListSyntax) {
3114 CandidateSet.clear();
3115
3116 for (ArrayRef<NamedDecl *>::iterator
3117 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
3118 NamedDecl *D = *Con;
3119 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3120 bool SuppressUserConversions = false;
3121
3122 // Find the constructor (which may be a template).
3123 CXXConstructorDecl *Constructor = nullptr;
3124 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3125 if (ConstructorTmpl)
3126 Constructor = cast<CXXConstructorDecl>(
3127 ConstructorTmpl->getTemplatedDecl());
3128 else {
3129 Constructor = cast<CXXConstructorDecl>(D);
3130
3131 // C++11 [over.best.ics]p4:
3132 // However, when considering the argument of a constructor or
3133 // user-defined conversion function that is a candidate:
3134 // -- by 13.3.1.3 when invoked for the copying/moving of a temporary
3135 // in the second step of a class copy-initialization,
3136 // -- by 13.3.1.7 when passing the initializer list as a single
3137 // argument or when the initializer list has exactly one elementand
3138 // a conversion to some class X or reference to (possibly
3139 // cv-qualified) X is considered for the first parameter of a
3140 // constructor of X, or
3141 // -- by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases,
3142 // only standard conversion sequences and ellipsis conversion sequences
3143 // are considered.
3144 if ((CopyInitializing || (InitListSyntax && Args.size() == 1)) &&
3145 Constructor->isCopyOrMoveConstructor())
3146 SuppressUserConversions = true;
3147 }
3148
3149 if (!Constructor->isInvalidDecl() &&
3150 (AllowExplicit || !Constructor->isExplicit()) &&
3151 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
3152 if (ConstructorTmpl)
3153 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3154 /*ExplicitArgs*/ nullptr, Args,
3155 CandidateSet, SuppressUserConversions);
3156 else {
3157 // C++ [over.match.copy]p1:
3158 // - When initializing a temporary to be bound to the first parameter
3159 // of a constructor that takes a reference to possibly cv-qualified
3160 // T as its first argument, called with a single argument in the
3161 // context of direct-initialization, explicit conversion functions
3162 // are also considered.
3163 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3164 Args.size() == 1 &&
3165 Constructor->isCopyOrMoveConstructor();
3166 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
3167 SuppressUserConversions,
3168 /*PartialOverloading=*/false,
3169 /*AllowExplicit=*/AllowExplicitConv);
3170 }
3171 }
3172 }
3173
3174 // Perform overload resolution and return the result.
3175 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3176 }
3177
3178 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3179 /// enumerates the constructors of the initialized entity and performs overload
3180 /// resolution to select the best.
3181 /// If InitListSyntax is true, this is list-initialization of a non-aggregate
3182 /// class type.
TryConstructorInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,MultiExprArg Args,QualType DestType,InitializationSequence & Sequence,bool InitListSyntax=false)3183 static void TryConstructorInitialization(Sema &S,
3184 const InitializedEntity &Entity,
3185 const InitializationKind &Kind,
3186 MultiExprArg Args, QualType DestType,
3187 InitializationSequence &Sequence,
3188 bool InitListSyntax = false) {
3189 assert((!InitListSyntax || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3190 "InitListSyntax must come with a single initializer list argument.");
3191
3192 // The type we're constructing needs to be complete.
3193 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
3194 Sequence.setIncompleteTypeFailure(DestType);
3195 return;
3196 }
3197
3198 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3199 assert(DestRecordType && "Constructor initialization requires record type");
3200 CXXRecordDecl *DestRecordDecl
3201 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3202
3203 // Build the candidate set directly in the initialization sequence
3204 // structure, so that it will persist if we fail.
3205 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3206
3207 // Determine whether we are allowed to call explicit constructors or
3208 // explicit conversion operators.
3209 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
3210 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3211
3212 // - Otherwise, if T is a class type, constructors are considered. The
3213 // applicable constructors are enumerated, and the best one is chosen
3214 // through overload resolution.
3215 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
3216 // The container holding the constructors can under certain conditions
3217 // be changed while iterating (e.g. because of deserialization).
3218 // To be safe we copy the lookup results to a new container.
3219 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
3220
3221 OverloadingResult Result = OR_No_Viable_Function;
3222 OverloadCandidateSet::iterator Best;
3223 bool AsInitializerList = false;
3224
3225 // C++11 [over.match.list]p1:
3226 // When objects of non-aggregate type T are list-initialized, overload
3227 // resolution selects the constructor in two phases:
3228 // - Initially, the candidate functions are the initializer-list
3229 // constructors of the class T and the argument list consists of the
3230 // initializer list as a single argument.
3231 if (InitListSyntax) {
3232 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
3233 AsInitializerList = true;
3234
3235 // If the initializer list has no elements and T has a default constructor,
3236 // the first phase is omitted.
3237 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
3238 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3239 CandidateSet, Ctors, Best,
3240 CopyInitialization, AllowExplicit,
3241 /*OnlyListConstructor=*/true,
3242 InitListSyntax);
3243
3244 // Time to unwrap the init list.
3245 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
3246 }
3247
3248 // C++11 [over.match.list]p1:
3249 // - If no viable initializer-list constructor is found, overload resolution
3250 // is performed again, where the candidate functions are all the
3251 // constructors of the class T and the argument list consists of the
3252 // elements of the initializer list.
3253 if (Result == OR_No_Viable_Function) {
3254 AsInitializerList = false;
3255 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3256 CandidateSet, Ctors, Best,
3257 CopyInitialization, AllowExplicit,
3258 /*OnlyListConstructors=*/false,
3259 InitListSyntax);
3260 }
3261 if (Result) {
3262 Sequence.SetOverloadFailure(InitListSyntax ?
3263 InitializationSequence::FK_ListConstructorOverloadFailed :
3264 InitializationSequence::FK_ConstructorOverloadFailed,
3265 Result);
3266 return;
3267 }
3268
3269 // C++11 [dcl.init]p6:
3270 // If a program calls for the default initialization of an object
3271 // of a const-qualified type T, T shall be a class type with a
3272 // user-provided default constructor.
3273 if (Kind.getKind() == InitializationKind::IK_Default &&
3274 Entity.getType().isConstQualified() &&
3275 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
3276 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3277 return;
3278 }
3279
3280 // C++11 [over.match.list]p1:
3281 // In copy-list-initialization, if an explicit constructor is chosen, the
3282 // initializer is ill-formed.
3283 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3284 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3285 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3286 return;
3287 }
3288
3289 // Add the constructor initialization step. Any cv-qualification conversion is
3290 // subsumed by the initialization.
3291 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3292 Sequence.AddConstructorInitializationStep(CtorDecl,
3293 Best->FoundDecl.getAccess(),
3294 DestType, HadMultipleCandidates,
3295 InitListSyntax, AsInitializerList);
3296 }
3297
3298 static bool
ResolveOverloadedFunctionForReferenceBinding(Sema & S,Expr * Initializer,QualType & SourceType,QualType & UnqualifiedSourceType,QualType UnqualifiedTargetType,InitializationSequence & Sequence)3299 ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3300 Expr *Initializer,
3301 QualType &SourceType,
3302 QualType &UnqualifiedSourceType,
3303 QualType UnqualifiedTargetType,
3304 InitializationSequence &Sequence) {
3305 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3306 S.Context.OverloadTy) {
3307 DeclAccessPair Found;
3308 bool HadMultipleCandidates = false;
3309 if (FunctionDecl *Fn
3310 = S.ResolveAddressOfOverloadedFunction(Initializer,
3311 UnqualifiedTargetType,
3312 false, Found,
3313 &HadMultipleCandidates)) {
3314 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3315 HadMultipleCandidates);
3316 SourceType = Fn->getType();
3317 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3318 } else if (!UnqualifiedTargetType->isRecordType()) {
3319 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3320 return true;
3321 }
3322 }
3323 return false;
3324 }
3325
3326 static void TryReferenceInitializationCore(Sema &S,
3327 const InitializedEntity &Entity,
3328 const InitializationKind &Kind,
3329 Expr *Initializer,
3330 QualType cv1T1, QualType T1,
3331 Qualifiers T1Quals,
3332 QualType cv2T2, QualType T2,
3333 Qualifiers T2Quals,
3334 InitializationSequence &Sequence);
3335
3336 static void TryValueInitialization(Sema &S,
3337 const InitializedEntity &Entity,
3338 const InitializationKind &Kind,
3339 InitializationSequence &Sequence,
3340 InitListExpr *InitList = nullptr);
3341
3342 /// \brief Attempt list initialization of a reference.
TryReferenceListInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,InitListExpr * InitList,InitializationSequence & Sequence)3343 static void TryReferenceListInitialization(Sema &S,
3344 const InitializedEntity &Entity,
3345 const InitializationKind &Kind,
3346 InitListExpr *InitList,
3347 InitializationSequence &Sequence) {
3348 // First, catch C++03 where this isn't possible.
3349 if (!S.getLangOpts().CPlusPlus11) {
3350 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3351 return;
3352 }
3353
3354 QualType DestType = Entity.getType();
3355 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3356 Qualifiers T1Quals;
3357 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3358
3359 // Reference initialization via an initializer list works thus:
3360 // If the initializer list consists of a single element that is
3361 // reference-related to the referenced type, bind directly to that element
3362 // (possibly creating temporaries).
3363 // Otherwise, initialize a temporary with the initializer list and
3364 // bind to that.
3365 if (InitList->getNumInits() == 1) {
3366 Expr *Initializer = InitList->getInit(0);
3367 QualType cv2T2 = Initializer->getType();
3368 Qualifiers T2Quals;
3369 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3370
3371 // If this fails, creating a temporary wouldn't work either.
3372 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3373 T1, Sequence))
3374 return;
3375
3376 SourceLocation DeclLoc = Initializer->getLocStart();
3377 bool dummy1, dummy2, dummy3;
3378 Sema::ReferenceCompareResult RefRelationship
3379 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3380 dummy2, dummy3);
3381 if (RefRelationship >= Sema::Ref_Related) {
3382 // Try to bind the reference here.
3383 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3384 T1Quals, cv2T2, T2, T2Quals, Sequence);
3385 if (Sequence)
3386 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3387 return;
3388 }
3389
3390 // Update the initializer if we've resolved an overloaded function.
3391 if (Sequence.step_begin() != Sequence.step_end())
3392 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3393 }
3394
3395 // Not reference-related. Create a temporary and bind to that.
3396 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3397
3398 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3399 if (Sequence) {
3400 if (DestType->isRValueReferenceType() ||
3401 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3402 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3403 else
3404 Sequence.SetFailed(
3405 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3406 }
3407 }
3408
3409 /// \brief Attempt list initialization (C++0x [dcl.init.list])
TryListInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,InitListExpr * InitList,InitializationSequence & Sequence)3410 static void TryListInitialization(Sema &S,
3411 const InitializedEntity &Entity,
3412 const InitializationKind &Kind,
3413 InitListExpr *InitList,
3414 InitializationSequence &Sequence) {
3415 QualType DestType = Entity.getType();
3416
3417 // C++ doesn't allow scalar initialization with more than one argument.
3418 // But C99 complex numbers are scalars and it makes sense there.
3419 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3420 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3421 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3422 return;
3423 }
3424 if (DestType->isReferenceType()) {
3425 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
3426 return;
3427 }
3428 if (DestType->isRecordType()) {
3429 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
3430 Sequence.setIncompleteTypeFailure(DestType);
3431 return;
3432 }
3433
3434 // C++11 [dcl.init.list]p3:
3435 // - If T is an aggregate, aggregate initialization is performed.
3436 if (!DestType->isAggregateType()) {
3437 if (S.getLangOpts().CPlusPlus11) {
3438 // - Otherwise, if the initializer list has no elements and T is a
3439 // class type with a default constructor, the object is
3440 // value-initialized.
3441 if (InitList->getNumInits() == 0) {
3442 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3443 if (RD->hasDefaultConstructor()) {
3444 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3445 return;
3446 }
3447 }
3448
3449 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3450 // an initializer_list object constructed [...]
3451 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3452 return;
3453
3454 // - Otherwise, if T is a class type, constructors are considered.
3455 Expr *InitListAsExpr = InitList;
3456 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3457 Sequence, /*InitListSyntax*/true);
3458 } else
3459 Sequence.SetFailed(
3460 InitializationSequence::FK_InitListBadDestinationType);
3461 return;
3462 }
3463 }
3464 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3465 InitList->getNumInits() == 1 &&
3466 InitList->getInit(0)->getType()->isRecordType()) {
3467 // - Otherwise, if the initializer list has a single element of type E
3468 // [...references are handled above...], the object or reference is
3469 // initialized from that element; if a narrowing conversion is required
3470 // to convert the element to T, the program is ill-formed.
3471 //
3472 // Per core-24034, this is direct-initialization if we were performing
3473 // direct-list-initialization and copy-initialization otherwise.
3474 // We can't use InitListChecker for this, because it always performs
3475 // copy-initialization. This only matters if we might use an 'explicit'
3476 // conversion operator, so we only need to handle the cases where the source
3477 // is of record type.
3478 InitializationKind SubKind =
3479 Kind.getKind() == InitializationKind::IK_DirectList
3480 ? InitializationKind::CreateDirect(Kind.getLocation(),
3481 InitList->getLBraceLoc(),
3482 InitList->getRBraceLoc())
3483 : Kind;
3484 Expr *SubInit[1] = { InitList->getInit(0) };
3485 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3486 /*TopLevelOfInitList*/true);
3487 if (Sequence)
3488 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3489 return;
3490 }
3491
3492 InitListChecker CheckInitList(S, Entity, InitList,
3493 DestType, /*VerifyOnly=*/true);
3494 if (CheckInitList.HadError()) {
3495 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3496 return;
3497 }
3498
3499 // Add the list initialization step with the built init list.
3500 Sequence.AddListInitializationStep(DestType);
3501 }
3502
3503 /// \brief Try a reference initialization that involves calling a conversion
3504 /// function.
TryRefInitWithConversionFunction(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,Expr * Initializer,bool AllowRValues,InitializationSequence & Sequence)3505 static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3506 const InitializedEntity &Entity,
3507 const InitializationKind &Kind,
3508 Expr *Initializer,
3509 bool AllowRValues,
3510 InitializationSequence &Sequence) {
3511 QualType DestType = Entity.getType();
3512 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3513 QualType T1 = cv1T1.getUnqualifiedType();
3514 QualType cv2T2 = Initializer->getType();
3515 QualType T2 = cv2T2.getUnqualifiedType();
3516
3517 bool DerivedToBase;
3518 bool ObjCConversion;
3519 bool ObjCLifetimeConversion;
3520 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
3521 T1, T2, DerivedToBase,
3522 ObjCConversion,
3523 ObjCLifetimeConversion) &&
3524 "Must have incompatible references when binding via conversion");
3525 (void)DerivedToBase;
3526 (void)ObjCConversion;
3527 (void)ObjCLifetimeConversion;
3528
3529 // Build the candidate set directly in the initialization sequence
3530 // structure, so that it will persist if we fail.
3531 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3532 CandidateSet.clear();
3533
3534 // Determine whether we are allowed to call explicit constructors or
3535 // explicit conversion operators.
3536 bool AllowExplicit = Kind.AllowExplicit();
3537 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3538
3539 const RecordType *T1RecordType = nullptr;
3540 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3541 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
3542 // The type we're converting to is a class type. Enumerate its constructors
3543 // to see if there is a suitable conversion.
3544 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
3545
3546 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
3547 // The container holding the constructors can under certain conditions
3548 // be changed while iterating (e.g. because of deserialization).
3549 // To be safe we copy the lookup results to a new container.
3550 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
3551 for (SmallVectorImpl<NamedDecl *>::iterator
3552 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3553 NamedDecl *D = *CI;
3554 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3555
3556 // Find the constructor (which may be a template).
3557 CXXConstructorDecl *Constructor = nullptr;
3558 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3559 if (ConstructorTmpl)
3560 Constructor = cast<CXXConstructorDecl>(
3561 ConstructorTmpl->getTemplatedDecl());
3562 else
3563 Constructor = cast<CXXConstructorDecl>(D);
3564
3565 if (!Constructor->isInvalidDecl() &&
3566 Constructor->isConvertingConstructor(AllowExplicit)) {
3567 if (ConstructorTmpl)
3568 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3569 /*ExplicitArgs*/ nullptr,
3570 Initializer, CandidateSet,
3571 /*SuppressUserConversions=*/true);
3572 else
3573 S.AddOverloadCandidate(Constructor, FoundDecl,
3574 Initializer, CandidateSet,
3575 /*SuppressUserConversions=*/true);
3576 }
3577 }
3578 }
3579 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3580 return OR_No_Viable_Function;
3581
3582 const RecordType *T2RecordType = nullptr;
3583 if ((T2RecordType = T2->getAs<RecordType>()) &&
3584 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
3585 // The type we're converting from is a class type, enumerate its conversion
3586 // functions.
3587 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3588
3589 std::pair<CXXRecordDecl::conversion_iterator,
3590 CXXRecordDecl::conversion_iterator>
3591 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3592 for (CXXRecordDecl::conversion_iterator
3593 I = Conversions.first, E = Conversions.second; I != E; ++I) {
3594 NamedDecl *D = *I;
3595 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3596 if (isa<UsingShadowDecl>(D))
3597 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3598
3599 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3600 CXXConversionDecl *Conv;
3601 if (ConvTemplate)
3602 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3603 else
3604 Conv = cast<CXXConversionDecl>(D);
3605
3606 // If the conversion function doesn't return a reference type,
3607 // it can't be considered for this conversion unless we're allowed to
3608 // consider rvalues.
3609 // FIXME: Do we need to make sure that we only consider conversion
3610 // candidates with reference-compatible results? That might be needed to
3611 // break recursion.
3612 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
3613 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3614 if (ConvTemplate)
3615 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3616 ActingDC, Initializer,
3617 DestType, CandidateSet,
3618 /*AllowObjCConversionOnExplicit=*/
3619 false);
3620 else
3621 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
3622 Initializer, DestType, CandidateSet,
3623 /*AllowObjCConversionOnExplicit=*/false);
3624 }
3625 }
3626 }
3627 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3628 return OR_No_Viable_Function;
3629
3630 SourceLocation DeclLoc = Initializer->getLocStart();
3631
3632 // Perform overload resolution. If it fails, return the failed result.
3633 OverloadCandidateSet::iterator Best;
3634 if (OverloadingResult Result
3635 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
3636 return Result;
3637
3638 FunctionDecl *Function = Best->Function;
3639 // This is the overload that will be used for this initialization step if we
3640 // use this initialization. Mark it as referenced.
3641 Function->setReferenced();
3642
3643 // Compute the returned type of the conversion.
3644 if (isa<CXXConversionDecl>(Function))
3645 T2 = Function->getReturnType();
3646 else
3647 T2 = cv1T1;
3648
3649 // Add the user-defined conversion step.
3650 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3651 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
3652 T2.getNonLValueExprType(S.Context),
3653 HadMultipleCandidates);
3654
3655 // Determine whether we need to perform derived-to-base or
3656 // cv-qualification adjustments.
3657 ExprValueKind VK = VK_RValue;
3658 if (T2->isLValueReferenceType())
3659 VK = VK_LValue;
3660 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
3661 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
3662
3663 bool NewDerivedToBase = false;
3664 bool NewObjCConversion = false;
3665 bool NewObjCLifetimeConversion = false;
3666 Sema::ReferenceCompareResult NewRefRelationship
3667 = S.CompareReferenceRelationship(DeclLoc, T1,
3668 T2.getNonLValueExprType(S.Context),
3669 NewDerivedToBase, NewObjCConversion,
3670 NewObjCLifetimeConversion);
3671 if (NewRefRelationship == Sema::Ref_Incompatible) {
3672 // If the type we've converted to is not reference-related to the
3673 // type we're looking for, then there is another conversion step
3674 // we need to perform to produce a temporary of the right type
3675 // that we'll be binding to.
3676 ImplicitConversionSequence ICS;
3677 ICS.setStandard();
3678 ICS.Standard = Best->FinalConversion;
3679 T2 = ICS.Standard.getToType(2);
3680 Sequence.AddConversionSequenceStep(ICS, T2);
3681 } else if (NewDerivedToBase)
3682 Sequence.AddDerivedToBaseCastStep(
3683 S.Context.getQualifiedType(T1,
3684 T2.getNonReferenceType().getQualifiers()),
3685 VK);
3686 else if (NewObjCConversion)
3687 Sequence.AddObjCObjectConversionStep(
3688 S.Context.getQualifiedType(T1,
3689 T2.getNonReferenceType().getQualifiers()));
3690
3691 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
3692 Sequence.AddQualificationConversionStep(cv1T1, VK);
3693
3694 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3695 return OR_Success;
3696 }
3697
3698 static void CheckCXX98CompatAccessibleCopy(Sema &S,
3699 const InitializedEntity &Entity,
3700 Expr *CurInitExpr);
3701
3702 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
TryReferenceInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,Expr * Initializer,InitializationSequence & Sequence)3703 static void TryReferenceInitialization(Sema &S,
3704 const InitializedEntity &Entity,
3705 const InitializationKind &Kind,
3706 Expr *Initializer,
3707 InitializationSequence &Sequence) {
3708 QualType DestType = Entity.getType();
3709 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3710 Qualifiers T1Quals;
3711 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3712 QualType cv2T2 = Initializer->getType();
3713 Qualifiers T2Quals;
3714 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3715
3716 // If the initializer is the address of an overloaded function, try
3717 // to resolve the overloaded function. If all goes well, T2 is the
3718 // type of the resulting function.
3719 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3720 T1, Sequence))
3721 return;
3722
3723 // Delegate everything else to a subfunction.
3724 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3725 T1Quals, cv2T2, T2, T2Quals, Sequence);
3726 }
3727
3728 /// Converts the target of reference initialization so that it has the
3729 /// appropriate qualifiers and value kind.
3730 ///
3731 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
3732 /// \code
3733 /// int x;
3734 /// const int &r = x;
3735 /// \endcode
3736 ///
3737 /// In this case the reference is binding to a bitfield lvalue, which isn't
3738 /// valid. Perform a load to create a lifetime-extended temporary instead.
3739 /// \code
3740 /// const int &r = someStruct.bitfield;
3741 /// \endcode
3742 static ExprValueKind
convertQualifiersAndValueKindIfNecessary(Sema & S,InitializationSequence & Sequence,Expr * Initializer,QualType cv1T1,Qualifiers T1Quals,Qualifiers T2Quals,bool IsLValueRef)3743 convertQualifiersAndValueKindIfNecessary(Sema &S,
3744 InitializationSequence &Sequence,
3745 Expr *Initializer,
3746 QualType cv1T1,
3747 Qualifiers T1Quals,
3748 Qualifiers T2Quals,
3749 bool IsLValueRef) {
3750 bool IsNonAddressableType = Initializer->refersToBitField() ||
3751 Initializer->refersToVectorElement();
3752
3753 if (IsNonAddressableType) {
3754 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
3755 // lvalue reference to a non-volatile const type, or the reference shall be
3756 // an rvalue reference.
3757 //
3758 // If not, we can't make a temporary and bind to that. Give up and allow the
3759 // error to be diagnosed later.
3760 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
3761 assert(Initializer->isGLValue());
3762 return Initializer->getValueKind();
3763 }
3764
3765 // Force a load so we can materialize a temporary.
3766 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
3767 return VK_RValue;
3768 }
3769
3770 if (T1Quals != T2Quals) {
3771 Sequence.AddQualificationConversionStep(cv1T1,
3772 Initializer->getValueKind());
3773 }
3774
3775 return Initializer->getValueKind();
3776 }
3777
3778
3779 /// \brief Reference initialization without resolving overloaded functions.
TryReferenceInitializationCore(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,Expr * Initializer,QualType cv1T1,QualType T1,Qualifiers T1Quals,QualType cv2T2,QualType T2,Qualifiers T2Quals,InitializationSequence & Sequence)3780 static void TryReferenceInitializationCore(Sema &S,
3781 const InitializedEntity &Entity,
3782 const InitializationKind &Kind,
3783 Expr *Initializer,
3784 QualType cv1T1, QualType T1,
3785 Qualifiers T1Quals,
3786 QualType cv2T2, QualType T2,
3787 Qualifiers T2Quals,
3788 InitializationSequence &Sequence) {
3789 QualType DestType = Entity.getType();
3790 SourceLocation DeclLoc = Initializer->getLocStart();
3791 // Compute some basic properties of the types and the initializer.
3792 bool isLValueRef = DestType->isLValueReferenceType();
3793 bool isRValueRef = !isLValueRef;
3794 bool DerivedToBase = false;
3795 bool ObjCConversion = false;
3796 bool ObjCLifetimeConversion = false;
3797 Expr::Classification InitCategory = Initializer->Classify(S.Context);
3798 Sema::ReferenceCompareResult RefRelationship
3799 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
3800 ObjCConversion, ObjCLifetimeConversion);
3801
3802 // C++0x [dcl.init.ref]p5:
3803 // A reference to type "cv1 T1" is initialized by an expression of type
3804 // "cv2 T2" as follows:
3805 //
3806 // - If the reference is an lvalue reference and the initializer
3807 // expression
3808 // Note the analogous bullet points for rvalue refs to functions. Because
3809 // there are no function rvalues in C++, rvalue refs to functions are treated
3810 // like lvalue refs.
3811 OverloadingResult ConvOvlResult = OR_Success;
3812 bool T1Function = T1->isFunctionType();
3813 if (isLValueRef || T1Function) {
3814 if (InitCategory.isLValue() &&
3815 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
3816 (Kind.isCStyleOrFunctionalCast() &&
3817 RefRelationship == Sema::Ref_Related))) {
3818 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
3819 // reference-compatible with "cv2 T2," or
3820 //
3821 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
3822 // bit-field when we're determining whether the reference initialization
3823 // can occur. However, we do pay attention to whether it is a bit-field
3824 // to decide whether we're actually binding to a temporary created from
3825 // the bit-field.
3826 if (DerivedToBase)
3827 Sequence.AddDerivedToBaseCastStep(
3828 S.Context.getQualifiedType(T1, T2Quals),
3829 VK_LValue);
3830 else if (ObjCConversion)
3831 Sequence.AddObjCObjectConversionStep(
3832 S.Context.getQualifiedType(T1, T2Quals));
3833
3834 ExprValueKind ValueKind =
3835 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
3836 cv1T1, T1Quals, T2Quals,
3837 isLValueRef);
3838 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
3839 return;
3840 }
3841
3842 // - has a class type (i.e., T2 is a class type), where T1 is not
3843 // reference-related to T2, and can be implicitly converted to an
3844 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3845 // with "cv3 T3" (this conversion is selected by enumerating the
3846 // applicable conversion functions (13.3.1.6) and choosing the best
3847 // one through overload resolution (13.3)),
3848 // If we have an rvalue ref to function type here, the rhs must be
3849 // an rvalue. DR1287 removed the "implicitly" here.
3850 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3851 (isLValueRef || InitCategory.isRValue())) {
3852 ConvOvlResult = TryRefInitWithConversionFunction(
3853 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
3854 if (ConvOvlResult == OR_Success)
3855 return;
3856 if (ConvOvlResult != OR_No_Viable_Function)
3857 Sequence.SetOverloadFailure(
3858 InitializationSequence::FK_ReferenceInitOverloadFailed,
3859 ConvOvlResult);
3860 }
3861 }
3862
3863 // - Otherwise, the reference shall be an lvalue reference to a
3864 // non-volatile const type (i.e., cv1 shall be const), or the reference
3865 // shall be an rvalue reference.
3866 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
3867 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3868 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3869 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3870 Sequence.SetOverloadFailure(
3871 InitializationSequence::FK_ReferenceInitOverloadFailed,
3872 ConvOvlResult);
3873 else
3874 Sequence.SetFailed(InitCategory.isLValue()
3875 ? (RefRelationship == Sema::Ref_Related
3876 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3877 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3878 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3879
3880 return;
3881 }
3882
3883 // - If the initializer expression
3884 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3885 // "cv1 T1" is reference-compatible with "cv2 T2"
3886 // Note: functions are handled below.
3887 if (!T1Function &&
3888 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
3889 (Kind.isCStyleOrFunctionalCast() &&
3890 RefRelationship == Sema::Ref_Related)) &&
3891 (InitCategory.isXValue() ||
3892 (InitCategory.isPRValue() && T2->isRecordType()) ||
3893 (InitCategory.isPRValue() && T2->isArrayType()))) {
3894 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3895 if (InitCategory.isPRValue() && T2->isRecordType()) {
3896 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3897 // compiler the freedom to perform a copy here or bind to the
3898 // object, while C++0x requires that we bind directly to the
3899 // object. Hence, we always bind to the object without making an
3900 // extra copy. However, in C++03 requires that we check for the
3901 // presence of a suitable copy constructor:
3902 //
3903 // The constructor that would be used to make the copy shall
3904 // be callable whether or not the copy is actually done.
3905 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
3906 Sequence.AddExtraneousCopyToTemporary(cv2T2);
3907 else if (S.getLangOpts().CPlusPlus11)
3908 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
3909 }
3910
3911 if (DerivedToBase)
3912 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3913 ValueKind);
3914 else if (ObjCConversion)
3915 Sequence.AddObjCObjectConversionStep(
3916 S.Context.getQualifiedType(T1, T2Quals));
3917
3918 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
3919 Initializer, cv1T1,
3920 T1Quals, T2Quals,
3921 isLValueRef);
3922
3923 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
3924 return;
3925 }
3926
3927 // - has a class type (i.e., T2 is a class type), where T1 is not
3928 // reference-related to T2, and can be implicitly converted to an
3929 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3930 // where "cv1 T1" is reference-compatible with "cv3 T3",
3931 //
3932 // DR1287 removes the "implicitly" here.
3933 if (T2->isRecordType()) {
3934 if (RefRelationship == Sema::Ref_Incompatible) {
3935 ConvOvlResult = TryRefInitWithConversionFunction(
3936 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
3937 if (ConvOvlResult)
3938 Sequence.SetOverloadFailure(
3939 InitializationSequence::FK_ReferenceInitOverloadFailed,
3940 ConvOvlResult);
3941
3942 return;
3943 }
3944
3945 if ((RefRelationship == Sema::Ref_Compatible ||
3946 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
3947 isRValueRef && InitCategory.isLValue()) {
3948 Sequence.SetFailed(
3949 InitializationSequence::FK_RValueReferenceBindingToLValue);
3950 return;
3951 }
3952
3953 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3954 return;
3955 }
3956
3957 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
3958 // from the initializer expression using the rules for a non-reference
3959 // copy-initialization (8.5). The reference is then bound to the
3960 // temporary. [...]
3961
3962 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3963
3964 // FIXME: Why do we use an implicit conversion here rather than trying
3965 // copy-initialization?
3966 ImplicitConversionSequence ICS
3967 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
3968 /*SuppressUserConversions=*/false,
3969 /*AllowExplicit=*/false,
3970 /*FIXME:InOverloadResolution=*/false,
3971 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3972 /*AllowObjCWritebackConversion=*/false);
3973
3974 if (ICS.isBad()) {
3975 // FIXME: Use the conversion function set stored in ICS to turn
3976 // this into an overloading ambiguity diagnostic. However, we need
3977 // to keep that set as an OverloadCandidateSet rather than as some
3978 // other kind of set.
3979 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3980 Sequence.SetOverloadFailure(
3981 InitializationSequence::FK_ReferenceInitOverloadFailed,
3982 ConvOvlResult);
3983 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3984 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3985 else
3986 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
3987 return;
3988 } else {
3989 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
3990 }
3991
3992 // [...] If T1 is reference-related to T2, cv1 must be the
3993 // same cv-qualification as, or greater cv-qualification
3994 // than, cv2; otherwise, the program is ill-formed.
3995 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3996 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
3997 if (RefRelationship == Sema::Ref_Related &&
3998 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
3999 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4000 return;
4001 }
4002
4003 // [...] If T1 is reference-related to T2 and the reference is an rvalue
4004 // reference, the initializer expression shall not be an lvalue.
4005 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4006 InitCategory.isLValue()) {
4007 Sequence.SetFailed(
4008 InitializationSequence::FK_RValueReferenceBindingToLValue);
4009 return;
4010 }
4011
4012 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4013 return;
4014 }
4015
4016 /// \brief Attempt character array initialization from a string literal
4017 /// (C++ [dcl.init.string], C99 6.7.8).
TryStringLiteralInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,Expr * Initializer,InitializationSequence & Sequence)4018 static void TryStringLiteralInitialization(Sema &S,
4019 const InitializedEntity &Entity,
4020 const InitializationKind &Kind,
4021 Expr *Initializer,
4022 InitializationSequence &Sequence) {
4023 Sequence.AddStringInitStep(Entity.getType());
4024 }
4025
4026 /// \brief Attempt value initialization (C++ [dcl.init]p7).
TryValueInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,InitializationSequence & Sequence,InitListExpr * InitList)4027 static void TryValueInitialization(Sema &S,
4028 const InitializedEntity &Entity,
4029 const InitializationKind &Kind,
4030 InitializationSequence &Sequence,
4031 InitListExpr *InitList) {
4032 assert((!InitList || InitList->getNumInits() == 0) &&
4033 "Shouldn't use value-init for non-empty init lists");
4034
4035 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4036 //
4037 // To value-initialize an object of type T means:
4038 QualType T = Entity.getType();
4039
4040 // -- if T is an array type, then each element is value-initialized;
4041 T = S.Context.getBaseElementType(T);
4042
4043 if (const RecordType *RT = T->getAs<RecordType>()) {
4044 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4045 bool NeedZeroInitialization = true;
4046 if (!S.getLangOpts().CPlusPlus11) {
4047 // C++98:
4048 // -- if T is a class type (clause 9) with a user-declared constructor
4049 // (12.1), then the default constructor for T is called (and the
4050 // initialization is ill-formed if T has no accessible default
4051 // constructor);
4052 if (ClassDecl->hasUserDeclaredConstructor())
4053 NeedZeroInitialization = false;
4054 } else {
4055 // C++11:
4056 // -- if T is a class type (clause 9) with either no default constructor
4057 // (12.1 [class.ctor]) or a default constructor that is user-provided
4058 // or deleted, then the object is default-initialized;
4059 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4060 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4061 NeedZeroInitialization = false;
4062 }
4063
4064 // -- if T is a (possibly cv-qualified) non-union class type without a
4065 // user-provided or deleted default constructor, then the object is
4066 // zero-initialized and, if T has a non-trivial default constructor,
4067 // default-initialized;
4068 // The 'non-union' here was removed by DR1502. The 'non-trivial default
4069 // constructor' part was removed by DR1507.
4070 if (NeedZeroInitialization)
4071 Sequence.AddZeroInitializationStep(Entity.getType());
4072
4073 // C++03:
4074 // -- if T is a non-union class type without a user-declared constructor,
4075 // then every non-static data member and base class component of T is
4076 // value-initialized;
4077 // [...] A program that calls for [...] value-initialization of an
4078 // entity of reference type is ill-formed.
4079 //
4080 // C++11 doesn't need this handling, because value-initialization does not
4081 // occur recursively there, and the implicit default constructor is
4082 // defined as deleted in the problematic cases.
4083 if (!S.getLangOpts().CPlusPlus11 &&
4084 ClassDecl->hasUninitializedReferenceMember()) {
4085 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
4086 return;
4087 }
4088
4089 // If this is list-value-initialization, pass the empty init list on when
4090 // building the constructor call. This affects the semantics of a few
4091 // things (such as whether an explicit default constructor can be called).
4092 Expr *InitListAsExpr = InitList;
4093 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4094 bool InitListSyntax = InitList;
4095
4096 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
4097 InitListSyntax);
4098 }
4099 }
4100
4101 Sequence.AddZeroInitializationStep(Entity.getType());
4102 }
4103
4104 /// \brief Attempt default initialization (C++ [dcl.init]p6).
TryDefaultInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,InitializationSequence & Sequence)4105 static void TryDefaultInitialization(Sema &S,
4106 const InitializedEntity &Entity,
4107 const InitializationKind &Kind,
4108 InitializationSequence &Sequence) {
4109 assert(Kind.getKind() == InitializationKind::IK_Default);
4110
4111 // C++ [dcl.init]p6:
4112 // To default-initialize an object of type T means:
4113 // - if T is an array type, each element is default-initialized;
4114 QualType DestType = S.Context.getBaseElementType(Entity.getType());
4115
4116 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4117 // constructor for T is called (and the initialization is ill-formed if
4118 // T has no accessible default constructor);
4119 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4120 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
4121 return;
4122 }
4123
4124 // - otherwise, no initialization is performed.
4125
4126 // If a program calls for the default initialization of an object of
4127 // a const-qualified type T, T shall be a class type with a user-provided
4128 // default constructor.
4129 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4130 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
4131 return;
4132 }
4133
4134 // If the destination type has a lifetime property, zero-initialize it.
4135 if (DestType.getQualifiers().hasObjCLifetime()) {
4136 Sequence.AddZeroInitializationStep(Entity.getType());
4137 return;
4138 }
4139 }
4140
4141 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4142 /// which enumerates all conversion functions and performs overload resolution
4143 /// to select the best.
TryUserDefinedConversion(Sema & S,QualType DestType,const InitializationKind & Kind,Expr * Initializer,InitializationSequence & Sequence,bool TopLevelOfInitList)4144 static void TryUserDefinedConversion(Sema &S,
4145 QualType DestType,
4146 const InitializationKind &Kind,
4147 Expr *Initializer,
4148 InitializationSequence &Sequence,
4149 bool TopLevelOfInitList) {
4150 assert(!DestType->isReferenceType() && "References are handled elsewhere");
4151 QualType SourceType = Initializer->getType();
4152 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4153 "Must have a class type to perform a user-defined conversion");
4154
4155 // Build the candidate set directly in the initialization sequence
4156 // structure, so that it will persist if we fail.
4157 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4158 CandidateSet.clear();
4159
4160 // Determine whether we are allowed to call explicit constructors or
4161 // explicit conversion operators.
4162 bool AllowExplicit = Kind.AllowExplicit();
4163
4164 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4165 // The type we're converting to is a class type. Enumerate its constructors
4166 // to see if there is a suitable conversion.
4167 CXXRecordDecl *DestRecordDecl
4168 = cast<CXXRecordDecl>(DestRecordType->getDecl());
4169
4170 // Try to complete the type we're converting to.
4171 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
4172 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4173 // The container holding the constructors can under certain conditions
4174 // be changed while iterating. To be safe we copy the lookup results
4175 // to a new container.
4176 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4177 for (SmallVectorImpl<NamedDecl *>::iterator
4178 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4179 Con != ConEnd; ++Con) {
4180 NamedDecl *D = *Con;
4181 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
4182
4183 // Find the constructor (which may be a template).
4184 CXXConstructorDecl *Constructor = nullptr;
4185 FunctionTemplateDecl *ConstructorTmpl
4186 = dyn_cast<FunctionTemplateDecl>(D);
4187 if (ConstructorTmpl)
4188 Constructor = cast<CXXConstructorDecl>(
4189 ConstructorTmpl->getTemplatedDecl());
4190 else
4191 Constructor = cast<CXXConstructorDecl>(D);
4192
4193 if (!Constructor->isInvalidDecl() &&
4194 Constructor->isConvertingConstructor(AllowExplicit)) {
4195 if (ConstructorTmpl)
4196 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4197 /*ExplicitArgs*/ nullptr,
4198 Initializer, CandidateSet,
4199 /*SuppressUserConversions=*/true);
4200 else
4201 S.AddOverloadCandidate(Constructor, FoundDecl,
4202 Initializer, CandidateSet,
4203 /*SuppressUserConversions=*/true);
4204 }
4205 }
4206 }
4207 }
4208
4209 SourceLocation DeclLoc = Initializer->getLocStart();
4210
4211 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4212 // The type we're converting from is a class type, enumerate its conversion
4213 // functions.
4214
4215 // We can only enumerate the conversion functions for a complete type; if
4216 // the type isn't complete, simply skip this step.
4217 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4218 CXXRecordDecl *SourceRecordDecl
4219 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4220
4221 std::pair<CXXRecordDecl::conversion_iterator,
4222 CXXRecordDecl::conversion_iterator>
4223 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
4224 for (CXXRecordDecl::conversion_iterator
4225 I = Conversions.first, E = Conversions.second; I != E; ++I) {
4226 NamedDecl *D = *I;
4227 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4228 if (isa<UsingShadowDecl>(D))
4229 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4230
4231 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4232 CXXConversionDecl *Conv;
4233 if (ConvTemplate)
4234 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4235 else
4236 Conv = cast<CXXConversionDecl>(D);
4237
4238 if (AllowExplicit || !Conv->isExplicit()) {
4239 if (ConvTemplate)
4240 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4241 ActingDC, Initializer, DestType,
4242 CandidateSet, AllowExplicit);
4243 else
4244 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4245 Initializer, DestType, CandidateSet,
4246 AllowExplicit);
4247 }
4248 }
4249 }
4250 }
4251
4252 // Perform overload resolution. If it fails, return the failed result.
4253 OverloadCandidateSet::iterator Best;
4254 if (OverloadingResult Result
4255 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4256 Sequence.SetOverloadFailure(
4257 InitializationSequence::FK_UserConversionOverloadFailed,
4258 Result);
4259 return;
4260 }
4261
4262 FunctionDecl *Function = Best->Function;
4263 Function->setReferenced();
4264 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4265
4266 if (isa<CXXConstructorDecl>(Function)) {
4267 // Add the user-defined conversion step. Any cv-qualification conversion is
4268 // subsumed by the initialization. Per DR5, the created temporary is of the
4269 // cv-unqualified type of the destination.
4270 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4271 DestType.getUnqualifiedType(),
4272 HadMultipleCandidates);
4273 return;
4274 }
4275
4276 // Add the user-defined conversion step that calls the conversion function.
4277 QualType ConvType = Function->getCallResultType();
4278 if (ConvType->getAs<RecordType>()) {
4279 // If we're converting to a class type, there may be an copy of
4280 // the resulting temporary object (possible to create an object of
4281 // a base class type). That copy is not a separate conversion, so
4282 // we just make a note of the actual destination type (possibly a
4283 // base class of the type returned by the conversion function) and
4284 // let the user-defined conversion step handle the conversion.
4285 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4286 HadMultipleCandidates);
4287 return;
4288 }
4289
4290 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4291 HadMultipleCandidates);
4292
4293 // If the conversion following the call to the conversion function
4294 // is interesting, add it as a separate step.
4295 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4296 Best->FinalConversion.Third) {
4297 ImplicitConversionSequence ICS;
4298 ICS.setStandard();
4299 ICS.Standard = Best->FinalConversion;
4300 Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4301 }
4302 }
4303
4304 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4305 /// a function with a pointer return type contains a 'return false;' statement.
4306 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4307 /// code using that header.
4308 ///
4309 /// Work around this by treating 'return false;' as zero-initializing the result
4310 /// if it's used in a pointer-returning function in a system header.
isLibstdcxxPointerReturnFalseHack(Sema & S,const InitializedEntity & Entity,const Expr * Init)4311 static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4312 const InitializedEntity &Entity,
4313 const Expr *Init) {
4314 return S.getLangOpts().CPlusPlus11 &&
4315 Entity.getKind() == InitializedEntity::EK_Result &&
4316 Entity.getType()->isPointerType() &&
4317 isa<CXXBoolLiteralExpr>(Init) &&
4318 !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4319 S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4320 }
4321
4322 /// The non-zero enum values here are indexes into diagnostic alternatives.
4323 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4324
4325 /// Determines whether this expression is an acceptable ICR source.
isInvalidICRSource(ASTContext & C,Expr * e,bool isAddressOf,bool & isWeakAccess)4326 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
4327 bool isAddressOf, bool &isWeakAccess) {
4328 // Skip parens.
4329 e = e->IgnoreParens();
4330
4331 // Skip address-of nodes.
4332 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4333 if (op->getOpcode() == UO_AddrOf)
4334 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4335 isWeakAccess);
4336
4337 // Skip certain casts.
4338 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4339 switch (ce->getCastKind()) {
4340 case CK_Dependent:
4341 case CK_BitCast:
4342 case CK_LValueBitCast:
4343 case CK_NoOp:
4344 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4345
4346 case CK_ArrayToPointerDecay:
4347 return IIK_nonscalar;
4348
4349 case CK_NullToPointer:
4350 return IIK_okay;
4351
4352 default:
4353 break;
4354 }
4355
4356 // If we have a declaration reference, it had better be a local variable.
4357 } else if (isa<DeclRefExpr>(e)) {
4358 // set isWeakAccess to true, to mean that there will be an implicit
4359 // load which requires a cleanup.
4360 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4361 isWeakAccess = true;
4362
4363 if (!isAddressOf) return IIK_nonlocal;
4364
4365 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4366 if (!var) return IIK_nonlocal;
4367
4368 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4369
4370 // If we have a conditional operator, check both sides.
4371 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4372 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4373 isWeakAccess))
4374 return iik;
4375
4376 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4377
4378 // These are never scalar.
4379 } else if (isa<ArraySubscriptExpr>(e)) {
4380 return IIK_nonscalar;
4381
4382 // Otherwise, it needs to be a null pointer constant.
4383 } else {
4384 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4385 ? IIK_okay : IIK_nonlocal);
4386 }
4387
4388 return IIK_nonlocal;
4389 }
4390
4391 /// Check whether the given expression is a valid operand for an
4392 /// indirect copy/restore.
checkIndirectCopyRestoreSource(Sema & S,Expr * src)4393 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4394 assert(src->isRValue());
4395 bool isWeakAccess = false;
4396 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4397 // If isWeakAccess to true, there will be an implicit
4398 // load which requires a cleanup.
4399 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4400 S.ExprNeedsCleanups = true;
4401
4402 if (iik == IIK_okay) return;
4403
4404 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4405 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4406 << src->getSourceRange();
4407 }
4408
4409 /// \brief Determine whether we have compatible array types for the
4410 /// purposes of GNU by-copy array initialization.
hasCompatibleArrayTypes(ASTContext & Context,const ArrayType * Dest,const ArrayType * Source)4411 static bool hasCompatibleArrayTypes(ASTContext &Context,
4412 const ArrayType *Dest,
4413 const ArrayType *Source) {
4414 // If the source and destination array types are equivalent, we're
4415 // done.
4416 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4417 return true;
4418
4419 // Make sure that the element types are the same.
4420 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4421 return false;
4422
4423 // The only mismatch we allow is when the destination is an
4424 // incomplete array type and the source is a constant array type.
4425 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4426 }
4427
tryObjCWritebackConversion(Sema & S,InitializationSequence & Sequence,const InitializedEntity & Entity,Expr * Initializer)4428 static bool tryObjCWritebackConversion(Sema &S,
4429 InitializationSequence &Sequence,
4430 const InitializedEntity &Entity,
4431 Expr *Initializer) {
4432 bool ArrayDecay = false;
4433 QualType ArgType = Initializer->getType();
4434 QualType ArgPointee;
4435 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4436 ArrayDecay = true;
4437 ArgPointee = ArgArrayType->getElementType();
4438 ArgType = S.Context.getPointerType(ArgPointee);
4439 }
4440
4441 // Handle write-back conversion.
4442 QualType ConvertedArgType;
4443 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4444 ConvertedArgType))
4445 return false;
4446
4447 // We should copy unless we're passing to an argument explicitly
4448 // marked 'out'.
4449 bool ShouldCopy = true;
4450 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4451 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4452
4453 // Do we need an lvalue conversion?
4454 if (ArrayDecay || Initializer->isGLValue()) {
4455 ImplicitConversionSequence ICS;
4456 ICS.setStandard();
4457 ICS.Standard.setAsIdentityConversion();
4458
4459 QualType ResultType;
4460 if (ArrayDecay) {
4461 ICS.Standard.First = ICK_Array_To_Pointer;
4462 ResultType = S.Context.getPointerType(ArgPointee);
4463 } else {
4464 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4465 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4466 }
4467
4468 Sequence.AddConversionSequenceStep(ICS, ResultType);
4469 }
4470
4471 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4472 return true;
4473 }
4474
TryOCLSamplerInitialization(Sema & S,InitializationSequence & Sequence,QualType DestType,Expr * Initializer)4475 static bool TryOCLSamplerInitialization(Sema &S,
4476 InitializationSequence &Sequence,
4477 QualType DestType,
4478 Expr *Initializer) {
4479 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4480 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4481 return false;
4482
4483 Sequence.AddOCLSamplerInitStep(DestType);
4484 return true;
4485 }
4486
4487 //
4488 // OpenCL 1.2 spec, s6.12.10
4489 //
4490 // The event argument can also be used to associate the
4491 // async_work_group_copy with a previous async copy allowing
4492 // an event to be shared by multiple async copies; otherwise
4493 // event should be zero.
4494 //
TryOCLZeroEventInitialization(Sema & S,InitializationSequence & Sequence,QualType DestType,Expr * Initializer)4495 static bool TryOCLZeroEventInitialization(Sema &S,
4496 InitializationSequence &Sequence,
4497 QualType DestType,
4498 Expr *Initializer) {
4499 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4500 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4501 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4502 return false;
4503
4504 Sequence.AddOCLZeroEventStep(DestType);
4505 return true;
4506 }
4507
InitializationSequence(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,MultiExprArg Args,bool TopLevelOfInitList)4508 InitializationSequence::InitializationSequence(Sema &S,
4509 const InitializedEntity &Entity,
4510 const InitializationKind &Kind,
4511 MultiExprArg Args,
4512 bool TopLevelOfInitList)
4513 : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
4514 InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4515 }
4516
InitializeFrom(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,MultiExprArg Args,bool TopLevelOfInitList)4517 void InitializationSequence::InitializeFrom(Sema &S,
4518 const InitializedEntity &Entity,
4519 const InitializationKind &Kind,
4520 MultiExprArg Args,
4521 bool TopLevelOfInitList) {
4522 ASTContext &Context = S.Context;
4523
4524 // Eliminate non-overload placeholder types in the arguments. We
4525 // need to do this before checking whether types are dependent
4526 // because lowering a pseudo-object expression might well give us
4527 // something of dependent type.
4528 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4529 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4530 // FIXME: should we be doing this here?
4531 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4532 if (result.isInvalid()) {
4533 SetFailed(FK_PlaceholderType);
4534 return;
4535 }
4536 Args[I] = result.get();
4537 }
4538
4539 // C++0x [dcl.init]p16:
4540 // The semantics of initializers are as follows. The destination type is
4541 // the type of the object or reference being initialized and the source
4542 // type is the type of the initializer expression. The source type is not
4543 // defined when the initializer is a braced-init-list or when it is a
4544 // parenthesized list of expressions.
4545 QualType DestType = Entity.getType();
4546
4547 if (DestType->isDependentType() ||
4548 Expr::hasAnyTypeDependentArguments(Args)) {
4549 SequenceKind = DependentSequence;
4550 return;
4551 }
4552
4553 // Almost everything is a normal sequence.
4554 setSequenceKind(NormalSequence);
4555
4556 QualType SourceType;
4557 Expr *Initializer = nullptr;
4558 if (Args.size() == 1) {
4559 Initializer = Args[0];
4560 if (S.getLangOpts().ObjC1) {
4561 if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
4562 DestType, Initializer->getType(),
4563 Initializer) ||
4564 S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
4565 Args[0] = Initializer;
4566 }
4567 if (!isa<InitListExpr>(Initializer))
4568 SourceType = Initializer->getType();
4569 }
4570
4571 // - If the initializer is a (non-parenthesized) braced-init-list, the
4572 // object is list-initialized (8.5.4).
4573 if (Kind.getKind() != InitializationKind::IK_Direct) {
4574 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4575 TryListInitialization(S, Entity, Kind, InitList, *this);
4576 return;
4577 }
4578 }
4579
4580 // - If the destination type is a reference type, see 8.5.3.
4581 if (DestType->isReferenceType()) {
4582 // C++0x [dcl.init.ref]p1:
4583 // A variable declared to be a T& or T&&, that is, "reference to type T"
4584 // (8.3.2), shall be initialized by an object, or function, of type T or
4585 // by an object that can be converted into a T.
4586 // (Therefore, multiple arguments are not permitted.)
4587 if (Args.size() != 1)
4588 SetFailed(FK_TooManyInitsForReference);
4589 else
4590 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
4591 return;
4592 }
4593
4594 // - If the initializer is (), the object is value-initialized.
4595 if (Kind.getKind() == InitializationKind::IK_Value ||
4596 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
4597 TryValueInitialization(S, Entity, Kind, *this);
4598 return;
4599 }
4600
4601 // Handle default initialization.
4602 if (Kind.getKind() == InitializationKind::IK_Default) {
4603 TryDefaultInitialization(S, Entity, Kind, *this);
4604 return;
4605 }
4606
4607 // - If the destination type is an array of characters, an array of
4608 // char16_t, an array of char32_t, or an array of wchar_t, and the
4609 // initializer is a string literal, see 8.5.2.
4610 // - Otherwise, if the destination type is an array, the program is
4611 // ill-formed.
4612 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
4613 if (Initializer && isa<VariableArrayType>(DestAT)) {
4614 SetFailed(FK_VariableLengthArrayHasInitializer);
4615 return;
4616 }
4617
4618 if (Initializer) {
4619 switch (IsStringInit(Initializer, DestAT, Context)) {
4620 case SIF_None:
4621 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4622 return;
4623 case SIF_NarrowStringIntoWideChar:
4624 SetFailed(FK_NarrowStringIntoWideCharArray);
4625 return;
4626 case SIF_WideStringIntoChar:
4627 SetFailed(FK_WideStringIntoCharArray);
4628 return;
4629 case SIF_IncompatWideStringIntoWideChar:
4630 SetFailed(FK_IncompatWideStringIntoWideChar);
4631 return;
4632 case SIF_Other:
4633 break;
4634 }
4635 }
4636
4637 // Note: as an GNU C extension, we allow initialization of an
4638 // array from a compound literal that creates an array of the same
4639 // type, so long as the initializer has no side effects.
4640 if (!S.getLangOpts().CPlusPlus && Initializer &&
4641 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4642 Initializer->getType()->isArrayType()) {
4643 const ArrayType *SourceAT
4644 = Context.getAsArrayType(Initializer->getType());
4645 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
4646 SetFailed(FK_ArrayTypeMismatch);
4647 else if (Initializer->HasSideEffects(S.Context))
4648 SetFailed(FK_NonConstantArrayInit);
4649 else {
4650 AddArrayInitStep(DestType);
4651 }
4652 }
4653 // Note: as a GNU C++ extension, we allow list-initialization of a
4654 // class member of array type from a parenthesized initializer list.
4655 else if (S.getLangOpts().CPlusPlus &&
4656 Entity.getKind() == InitializedEntity::EK_Member &&
4657 Initializer && isa<InitListExpr>(Initializer)) {
4658 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4659 *this);
4660 AddParenthesizedArrayInitStep(DestType);
4661 } else if (DestAT->getElementType()->isCharType())
4662 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
4663 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4664 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
4665 else
4666 SetFailed(FK_ArrayNeedsInitList);
4667
4668 return;
4669 }
4670
4671 // Determine whether we should consider writeback conversions for
4672 // Objective-C ARC.
4673 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
4674 Entity.isParameterKind();
4675
4676 // We're at the end of the line for C: it's either a write-back conversion
4677 // or it's a C assignment. There's no need to check anything else.
4678 if (!S.getLangOpts().CPlusPlus) {
4679 // If allowed, check whether this is an Objective-C writeback conversion.
4680 if (allowObjCWritebackConversion &&
4681 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
4682 return;
4683 }
4684
4685 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4686 return;
4687
4688 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4689 return;
4690
4691 // Handle initialization in C
4692 AddCAssignmentStep(DestType);
4693 MaybeProduceObjCObject(S, *this, Entity);
4694 return;
4695 }
4696
4697 assert(S.getLangOpts().CPlusPlus);
4698
4699 // - If the destination type is a (possibly cv-qualified) class type:
4700 if (DestType->isRecordType()) {
4701 // - If the initialization is direct-initialization, or if it is
4702 // copy-initialization where the cv-unqualified version of the
4703 // source type is the same class as, or a derived class of, the
4704 // class of the destination, constructors are considered. [...]
4705 if (Kind.getKind() == InitializationKind::IK_Direct ||
4706 (Kind.getKind() == InitializationKind::IK_Copy &&
4707 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4708 S.IsDerivedFrom(SourceType, DestType))))
4709 TryConstructorInitialization(S, Entity, Kind, Args,
4710 DestType, *this);
4711 // - Otherwise (i.e., for the remaining copy-initialization cases),
4712 // user-defined conversion sequences that can convert from the source
4713 // type to the destination type or (when a conversion function is
4714 // used) to a derived class thereof are enumerated as described in
4715 // 13.3.1.4, and the best one is chosen through overload resolution
4716 // (13.3).
4717 else
4718 TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
4719 TopLevelOfInitList);
4720 return;
4721 }
4722
4723 if (Args.size() > 1) {
4724 SetFailed(FK_TooManyInitsForScalar);
4725 return;
4726 }
4727 assert(Args.size() == 1 && "Zero-argument case handled above");
4728
4729 // - Otherwise, if the source type is a (possibly cv-qualified) class
4730 // type, conversion functions are considered.
4731 if (!SourceType.isNull() && SourceType->isRecordType()) {
4732 // For a conversion to _Atomic(T) from either T or a class type derived
4733 // from T, initialize the T object then convert to _Atomic type.
4734 bool NeedAtomicConversion = false;
4735 if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
4736 if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
4737 S.IsDerivedFrom(SourceType, Atomic->getValueType())) {
4738 DestType = Atomic->getValueType();
4739 NeedAtomicConversion = true;
4740 }
4741 }
4742
4743 TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
4744 TopLevelOfInitList);
4745 MaybeProduceObjCObject(S, *this, Entity);
4746 if (!Failed() && NeedAtomicConversion)
4747 AddAtomicConversionStep(Entity.getType());
4748 return;
4749 }
4750
4751 // - Otherwise, the initial value of the object being initialized is the
4752 // (possibly converted) value of the initializer expression. Standard
4753 // conversions (Clause 4) will be used, if necessary, to convert the
4754 // initializer expression to the cv-unqualified version of the
4755 // destination type; no user-defined conversions are considered.
4756
4757 ImplicitConversionSequence ICS
4758 = S.TryImplicitConversion(Initializer, DestType,
4759 /*SuppressUserConversions*/true,
4760 /*AllowExplicitConversions*/ false,
4761 /*InOverloadResolution*/ false,
4762 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4763 allowObjCWritebackConversion);
4764
4765 if (ICS.isStandard() &&
4766 ICS.Standard.Second == ICK_Writeback_Conversion) {
4767 // Objective-C ARC writeback conversion.
4768
4769 // We should copy unless we're passing to an argument explicitly
4770 // marked 'out'.
4771 bool ShouldCopy = true;
4772 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4773 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4774
4775 // If there was an lvalue adjustment, add it as a separate conversion.
4776 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4777 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4778 ImplicitConversionSequence LvalueICS;
4779 LvalueICS.setStandard();
4780 LvalueICS.Standard.setAsIdentityConversion();
4781 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4782 LvalueICS.Standard.First = ICS.Standard.First;
4783 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
4784 }
4785
4786 AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
4787 } else if (ICS.isBad()) {
4788 DeclAccessPair dap;
4789 if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
4790 AddZeroInitializationStep(Entity.getType());
4791 } else if (Initializer->getType() == Context.OverloadTy &&
4792 !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
4793 false, dap))
4794 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4795 else
4796 SetFailed(InitializationSequence::FK_ConversionFailed);
4797 } else {
4798 AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4799
4800 MaybeProduceObjCObject(S, *this, Entity);
4801 }
4802 }
4803
~InitializationSequence()4804 InitializationSequence::~InitializationSequence() {
4805 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
4806 StepEnd = Steps.end();
4807 Step != StepEnd; ++Step)
4808 Step->Destroy();
4809 }
4810
4811 //===----------------------------------------------------------------------===//
4812 // Perform initialization
4813 //===----------------------------------------------------------------------===//
4814 static Sema::AssignmentAction
getAssignmentAction(const InitializedEntity & Entity,bool Diagnose=false)4815 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
4816 switch(Entity.getKind()) {
4817 case InitializedEntity::EK_Variable:
4818 case InitializedEntity::EK_New:
4819 case InitializedEntity::EK_Exception:
4820 case InitializedEntity::EK_Base:
4821 case InitializedEntity::EK_Delegating:
4822 return Sema::AA_Initializing;
4823
4824 case InitializedEntity::EK_Parameter:
4825 if (Entity.getDecl() &&
4826 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4827 return Sema::AA_Sending;
4828
4829 return Sema::AA_Passing;
4830
4831 case InitializedEntity::EK_Parameter_CF_Audited:
4832 if (Entity.getDecl() &&
4833 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4834 return Sema::AA_Sending;
4835
4836 return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
4837
4838 case InitializedEntity::EK_Result:
4839 return Sema::AA_Returning;
4840
4841 case InitializedEntity::EK_Temporary:
4842 case InitializedEntity::EK_RelatedResult:
4843 // FIXME: Can we tell apart casting vs. converting?
4844 return Sema::AA_Casting;
4845
4846 case InitializedEntity::EK_Member:
4847 case InitializedEntity::EK_ArrayElement:
4848 case InitializedEntity::EK_VectorElement:
4849 case InitializedEntity::EK_ComplexElement:
4850 case InitializedEntity::EK_BlockElement:
4851 case InitializedEntity::EK_LambdaCapture:
4852 case InitializedEntity::EK_CompoundLiteralInit:
4853 return Sema::AA_Initializing;
4854 }
4855
4856 llvm_unreachable("Invalid EntityKind!");
4857 }
4858
4859 /// \brief Whether we should bind a created object as a temporary when
4860 /// initializing the given entity.
shouldBindAsTemporary(const InitializedEntity & Entity)4861 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
4862 switch (Entity.getKind()) {
4863 case InitializedEntity::EK_ArrayElement:
4864 case InitializedEntity::EK_Member:
4865 case InitializedEntity::EK_Result:
4866 case InitializedEntity::EK_New:
4867 case InitializedEntity::EK_Variable:
4868 case InitializedEntity::EK_Base:
4869 case InitializedEntity::EK_Delegating:
4870 case InitializedEntity::EK_VectorElement:
4871 case InitializedEntity::EK_ComplexElement:
4872 case InitializedEntity::EK_Exception:
4873 case InitializedEntity::EK_BlockElement:
4874 case InitializedEntity::EK_LambdaCapture:
4875 case InitializedEntity::EK_CompoundLiteralInit:
4876 return false;
4877
4878 case InitializedEntity::EK_Parameter:
4879 case InitializedEntity::EK_Parameter_CF_Audited:
4880 case InitializedEntity::EK_Temporary:
4881 case InitializedEntity::EK_RelatedResult:
4882 return true;
4883 }
4884
4885 llvm_unreachable("missed an InitializedEntity kind?");
4886 }
4887
4888 /// \brief Whether the given entity, when initialized with an object
4889 /// created for that initialization, requires destruction.
shouldDestroyTemporary(const InitializedEntity & Entity)4890 static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4891 switch (Entity.getKind()) {
4892 case InitializedEntity::EK_Result:
4893 case InitializedEntity::EK_New:
4894 case InitializedEntity::EK_Base:
4895 case InitializedEntity::EK_Delegating:
4896 case InitializedEntity::EK_VectorElement:
4897 case InitializedEntity::EK_ComplexElement:
4898 case InitializedEntity::EK_BlockElement:
4899 case InitializedEntity::EK_LambdaCapture:
4900 return false;
4901
4902 case InitializedEntity::EK_Member:
4903 case InitializedEntity::EK_Variable:
4904 case InitializedEntity::EK_Parameter:
4905 case InitializedEntity::EK_Parameter_CF_Audited:
4906 case InitializedEntity::EK_Temporary:
4907 case InitializedEntity::EK_ArrayElement:
4908 case InitializedEntity::EK_Exception:
4909 case InitializedEntity::EK_CompoundLiteralInit:
4910 case InitializedEntity::EK_RelatedResult:
4911 return true;
4912 }
4913
4914 llvm_unreachable("missed an InitializedEntity kind?");
4915 }
4916
4917 /// \brief Look for copy and move constructors and constructor templates, for
4918 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
LookupCopyAndMoveConstructors(Sema & S,OverloadCandidateSet & CandidateSet,CXXRecordDecl * Class,Expr * CurInitExpr)4919 static void LookupCopyAndMoveConstructors(Sema &S,
4920 OverloadCandidateSet &CandidateSet,
4921 CXXRecordDecl *Class,
4922 Expr *CurInitExpr) {
4923 DeclContext::lookup_result R = S.LookupConstructors(Class);
4924 // The container holding the constructors can under certain conditions
4925 // be changed while iterating (e.g. because of deserialization).
4926 // To be safe we copy the lookup results to a new container.
4927 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
4928 for (SmallVectorImpl<NamedDecl *>::iterator
4929 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4930 NamedDecl *D = *CI;
4931 CXXConstructorDecl *Constructor = nullptr;
4932
4933 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
4934 // Handle copy/moveconstructors, only.
4935 if (!Constructor || Constructor->isInvalidDecl() ||
4936 !Constructor->isCopyOrMoveConstructor() ||
4937 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4938 continue;
4939
4940 DeclAccessPair FoundDecl
4941 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4942 S.AddOverloadCandidate(Constructor, FoundDecl,
4943 CurInitExpr, CandidateSet);
4944 continue;
4945 }
4946
4947 // Handle constructor templates.
4948 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
4949 if (ConstructorTmpl->isInvalidDecl())
4950 continue;
4951
4952 Constructor = cast<CXXConstructorDecl>(
4953 ConstructorTmpl->getTemplatedDecl());
4954 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4955 continue;
4956
4957 // FIXME: Do we need to limit this to copy-constructor-like
4958 // candidates?
4959 DeclAccessPair FoundDecl
4960 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
4961 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, nullptr,
4962 CurInitExpr, CandidateSet, true);
4963 }
4964 }
4965
4966 /// \brief Get the location at which initialization diagnostics should appear.
getInitializationLoc(const InitializedEntity & Entity,Expr * Initializer)4967 static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4968 Expr *Initializer) {
4969 switch (Entity.getKind()) {
4970 case InitializedEntity::EK_Result:
4971 return Entity.getReturnLoc();
4972
4973 case InitializedEntity::EK_Exception:
4974 return Entity.getThrowLoc();
4975
4976 case InitializedEntity::EK_Variable:
4977 return Entity.getDecl()->getLocation();
4978
4979 case InitializedEntity::EK_LambdaCapture:
4980 return Entity.getCaptureLoc();
4981
4982 case InitializedEntity::EK_ArrayElement:
4983 case InitializedEntity::EK_Member:
4984 case InitializedEntity::EK_Parameter:
4985 case InitializedEntity::EK_Parameter_CF_Audited:
4986 case InitializedEntity::EK_Temporary:
4987 case InitializedEntity::EK_New:
4988 case InitializedEntity::EK_Base:
4989 case InitializedEntity::EK_Delegating:
4990 case InitializedEntity::EK_VectorElement:
4991 case InitializedEntity::EK_ComplexElement:
4992 case InitializedEntity::EK_BlockElement:
4993 case InitializedEntity::EK_CompoundLiteralInit:
4994 case InitializedEntity::EK_RelatedResult:
4995 return Initializer->getLocStart();
4996 }
4997 llvm_unreachable("missed an InitializedEntity kind?");
4998 }
4999
5000 /// \brief Make a (potentially elidable) temporary copy of the object
5001 /// provided by the given initializer by calling the appropriate copy
5002 /// constructor.
5003 ///
5004 /// \param S The Sema object used for type-checking.
5005 ///
5006 /// \param T The type of the temporary object, which must either be
5007 /// the type of the initializer expression or a superclass thereof.
5008 ///
5009 /// \param Entity The entity being initialized.
5010 ///
5011 /// \param CurInit The initializer expression.
5012 ///
5013 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5014 /// is permitted in C++03 (but not C++0x) when binding a reference to
5015 /// an rvalue.
5016 ///
5017 /// \returns An expression that copies the initializer expression into
5018 /// a temporary object, or an error expression if a copy could not be
5019 /// created.
CopyObject(Sema & S,QualType T,const InitializedEntity & Entity,ExprResult CurInit,bool IsExtraneousCopy)5020 static ExprResult CopyObject(Sema &S,
5021 QualType T,
5022 const InitializedEntity &Entity,
5023 ExprResult CurInit,
5024 bool IsExtraneousCopy) {
5025 // Determine which class type we're copying to.
5026 Expr *CurInitExpr = (Expr *)CurInit.get();
5027 CXXRecordDecl *Class = nullptr;
5028 if (const RecordType *Record = T->getAs<RecordType>())
5029 Class = cast<CXXRecordDecl>(Record->getDecl());
5030 if (!Class)
5031 return CurInit;
5032
5033 // C++0x [class.copy]p32:
5034 // When certain criteria are met, an implementation is allowed to
5035 // omit the copy/move construction of a class object, even if the
5036 // copy/move constructor and/or destructor for the object have
5037 // side effects. [...]
5038 // - when a temporary class object that has not been bound to a
5039 // reference (12.2) would be copied/moved to a class object
5040 // with the same cv-unqualified type, the copy/move operation
5041 // can be omitted by constructing the temporary object
5042 // directly into the target of the omitted copy/move
5043 //
5044 // Note that the other three bullets are handled elsewhere. Copy
5045 // elision for return statements and throw expressions are handled as part
5046 // of constructor initialization, while copy elision for exception handlers
5047 // is handled by the run-time.
5048 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
5049 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5050
5051 // Make sure that the type we are copying is complete.
5052 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5053 return CurInit;
5054
5055 // Perform overload resolution using the class's copy/move constructors.
5056 // Only consider constructors and constructor templates. Per
5057 // C++0x [dcl.init]p16, second bullet to class types, this initialization
5058 // is direct-initialization.
5059 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5060 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
5061
5062 bool HadMultipleCandidates = (CandidateSet.size() > 1);
5063
5064 OverloadCandidateSet::iterator Best;
5065 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
5066 case OR_Success:
5067 break;
5068
5069 case OR_No_Viable_Function:
5070 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5071 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5072 : diag::err_temp_copy_no_viable)
5073 << (int)Entity.getKind() << CurInitExpr->getType()
5074 << CurInitExpr->getSourceRange();
5075 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5076 if (!IsExtraneousCopy || S.isSFINAEContext())
5077 return ExprError();
5078 return CurInit;
5079
5080 case OR_Ambiguous:
5081 S.Diag(Loc, diag::err_temp_copy_ambiguous)
5082 << (int)Entity.getKind() << CurInitExpr->getType()
5083 << CurInitExpr->getSourceRange();
5084 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5085 return ExprError();
5086
5087 case OR_Deleted:
5088 S.Diag(Loc, diag::err_temp_copy_deleted)
5089 << (int)Entity.getKind() << CurInitExpr->getType()
5090 << CurInitExpr->getSourceRange();
5091 S.NoteDeletedFunction(Best->Function);
5092 return ExprError();
5093 }
5094
5095 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5096 SmallVector<Expr*, 8> ConstructorArgs;
5097 CurInit.get(); // Ownership transferred into MultiExprArg, below.
5098
5099 S.CheckConstructorAccess(Loc, Constructor, Entity,
5100 Best->FoundDecl.getAccess(), IsExtraneousCopy);
5101
5102 if (IsExtraneousCopy) {
5103 // If this is a totally extraneous copy for C++03 reference
5104 // binding purposes, just return the original initialization
5105 // expression. We don't generate an (elided) copy operation here
5106 // because doing so would require us to pass down a flag to avoid
5107 // infinite recursion, where each step adds another extraneous,
5108 // elidable copy.
5109
5110 // Instantiate the default arguments of any extra parameters in
5111 // the selected copy constructor, as if we were going to create a
5112 // proper call to the copy constructor.
5113 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5114 ParmVarDecl *Parm = Constructor->getParamDecl(I);
5115 if (S.RequireCompleteType(Loc, Parm->getType(),
5116 diag::err_call_incomplete_argument))
5117 break;
5118
5119 // Build the default argument expression; we don't actually care
5120 // if this succeeds or not, because this routine will complain
5121 // if there was a problem.
5122 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5123 }
5124
5125 return CurInitExpr;
5126 }
5127
5128 // Determine the arguments required to actually perform the
5129 // constructor call (we might have derived-to-base conversions, or
5130 // the copy constructor may have default arguments).
5131 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5132 return ExprError();
5133
5134 // Actually perform the constructor call.
5135 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
5136 ConstructorArgs,
5137 HadMultipleCandidates,
5138 /*ListInit*/ false,
5139 /*StdInitListInit*/ false,
5140 /*ZeroInit*/ false,
5141 CXXConstructExpr::CK_Complete,
5142 SourceRange());
5143
5144 // If we're supposed to bind temporaries, do so.
5145 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5146 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5147 return CurInit;
5148 }
5149
5150 /// \brief Check whether elidable copy construction for binding a reference to
5151 /// a temporary would have succeeded if we were building in C++98 mode, for
5152 /// -Wc++98-compat.
CheckCXX98CompatAccessibleCopy(Sema & S,const InitializedEntity & Entity,Expr * CurInitExpr)5153 static void CheckCXX98CompatAccessibleCopy(Sema &S,
5154 const InitializedEntity &Entity,
5155 Expr *CurInitExpr) {
5156 assert(S.getLangOpts().CPlusPlus11);
5157
5158 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5159 if (!Record)
5160 return;
5161
5162 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5163 if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5164 return;
5165
5166 // Find constructors which would have been considered.
5167 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5168 LookupCopyAndMoveConstructors(
5169 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5170
5171 // Perform overload resolution.
5172 OverloadCandidateSet::iterator Best;
5173 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5174
5175 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5176 << OR << (int)Entity.getKind() << CurInitExpr->getType()
5177 << CurInitExpr->getSourceRange();
5178
5179 switch (OR) {
5180 case OR_Success:
5181 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5182 Entity, Best->FoundDecl.getAccess(), Diag);
5183 // FIXME: Check default arguments as far as that's possible.
5184 break;
5185
5186 case OR_No_Viable_Function:
5187 S.Diag(Loc, Diag);
5188 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5189 break;
5190
5191 case OR_Ambiguous:
5192 S.Diag(Loc, Diag);
5193 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5194 break;
5195
5196 case OR_Deleted:
5197 S.Diag(Loc, Diag);
5198 S.NoteDeletedFunction(Best->Function);
5199 break;
5200 }
5201 }
5202
PrintInitLocationNote(Sema & S,const InitializedEntity & Entity)5203 void InitializationSequence::PrintInitLocationNote(Sema &S,
5204 const InitializedEntity &Entity) {
5205 if (Entity.isParameterKind() && Entity.getDecl()) {
5206 if (Entity.getDecl()->getLocation().isInvalid())
5207 return;
5208
5209 if (Entity.getDecl()->getDeclName())
5210 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5211 << Entity.getDecl()->getDeclName();
5212 else
5213 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5214 }
5215 else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5216 Entity.getMethodDecl())
5217 S.Diag(Entity.getMethodDecl()->getLocation(),
5218 diag::note_method_return_type_change)
5219 << Entity.getMethodDecl()->getDeclName();
5220 }
5221
isReferenceBinding(const InitializationSequence::Step & s)5222 static bool isReferenceBinding(const InitializationSequence::Step &s) {
5223 return s.Kind == InitializationSequence::SK_BindReference ||
5224 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5225 }
5226
5227 /// Returns true if the parameters describe a constructor initialization of
5228 /// an explicit temporary object, e.g. "Point(x, y)".
isExplicitTemporary(const InitializedEntity & Entity,const InitializationKind & Kind,unsigned NumArgs)5229 static bool isExplicitTemporary(const InitializedEntity &Entity,
5230 const InitializationKind &Kind,
5231 unsigned NumArgs) {
5232 switch (Entity.getKind()) {
5233 case InitializedEntity::EK_Temporary:
5234 case InitializedEntity::EK_CompoundLiteralInit:
5235 case InitializedEntity::EK_RelatedResult:
5236 break;
5237 default:
5238 return false;
5239 }
5240
5241 switch (Kind.getKind()) {
5242 case InitializationKind::IK_DirectList:
5243 return true;
5244 // FIXME: Hack to work around cast weirdness.
5245 case InitializationKind::IK_Direct:
5246 case InitializationKind::IK_Value:
5247 return NumArgs != 1;
5248 default:
5249 return false;
5250 }
5251 }
5252
5253 static ExprResult
PerformConstructorInitialization(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,MultiExprArg Args,const InitializationSequence::Step & Step,bool & ConstructorInitRequiresZeroInit,bool IsListInitialization,bool IsStdInitListInitialization,SourceLocation LBraceLoc,SourceLocation RBraceLoc)5254 PerformConstructorInitialization(Sema &S,
5255 const InitializedEntity &Entity,
5256 const InitializationKind &Kind,
5257 MultiExprArg Args,
5258 const InitializationSequence::Step& Step,
5259 bool &ConstructorInitRequiresZeroInit,
5260 bool IsListInitialization,
5261 bool IsStdInitListInitialization,
5262 SourceLocation LBraceLoc,
5263 SourceLocation RBraceLoc) {
5264 unsigned NumArgs = Args.size();
5265 CXXConstructorDecl *Constructor
5266 = cast<CXXConstructorDecl>(Step.Function.Function);
5267 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5268
5269 // Build a call to the selected constructor.
5270 SmallVector<Expr*, 8> ConstructorArgs;
5271 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5272 ? Kind.getEqualLoc()
5273 : Kind.getLocation();
5274
5275 if (Kind.getKind() == InitializationKind::IK_Default) {
5276 // Force even a trivial, implicit default constructor to be
5277 // semantically checked. We do this explicitly because we don't build
5278 // the definition for completely trivial constructors.
5279 assert(Constructor->getParent() && "No parent class for constructor.");
5280 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5281 Constructor->isTrivial() && !Constructor->isUsed(false))
5282 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5283 }
5284
5285 ExprResult CurInit((Expr *)nullptr);
5286
5287 // C++ [over.match.copy]p1:
5288 // - When initializing a temporary to be bound to the first parameter
5289 // of a constructor that takes a reference to possibly cv-qualified
5290 // T as its first argument, called with a single argument in the
5291 // context of direct-initialization, explicit conversion functions
5292 // are also considered.
5293 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5294 Args.size() == 1 &&
5295 Constructor->isCopyOrMoveConstructor();
5296
5297 // Determine the arguments required to actually perform the constructor
5298 // call.
5299 if (S.CompleteConstructorCall(Constructor, Args,
5300 Loc, ConstructorArgs,
5301 AllowExplicitConv,
5302 IsListInitialization))
5303 return ExprError();
5304
5305
5306 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5307 // An explicitly-constructed temporary, e.g., X(1, 2).
5308 S.MarkFunctionReferenced(Loc, Constructor);
5309 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5310 return ExprError();
5311
5312 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5313 if (!TSInfo)
5314 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5315 SourceRange ParenOrBraceRange =
5316 (Kind.getKind() == InitializationKind::IK_DirectList)
5317 ? SourceRange(LBraceLoc, RBraceLoc)
5318 : Kind.getParenRange();
5319
5320 CurInit = new (S.Context) CXXTemporaryObjectExpr(
5321 S.Context, Constructor, TSInfo, ConstructorArgs, ParenOrBraceRange,
5322 HadMultipleCandidates, IsListInitialization,
5323 IsStdInitListInitialization, ConstructorInitRequiresZeroInit);
5324 } else {
5325 CXXConstructExpr::ConstructionKind ConstructKind =
5326 CXXConstructExpr::CK_Complete;
5327
5328 if (Entity.getKind() == InitializedEntity::EK_Base) {
5329 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5330 CXXConstructExpr::CK_VirtualBase :
5331 CXXConstructExpr::CK_NonVirtualBase;
5332 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5333 ConstructKind = CXXConstructExpr::CK_Delegating;
5334 }
5335
5336 // Only get the parenthesis or brace range if it is a list initialization or
5337 // direct construction.
5338 SourceRange ParenOrBraceRange;
5339 if (IsListInitialization)
5340 ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5341 else if (Kind.getKind() == InitializationKind::IK_Direct)
5342 ParenOrBraceRange = Kind.getParenRange();
5343
5344 // If the entity allows NRVO, mark the construction as elidable
5345 // unconditionally.
5346 if (Entity.allowsNRVO())
5347 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5348 Constructor, /*Elidable=*/true,
5349 ConstructorArgs,
5350 HadMultipleCandidates,
5351 IsListInitialization,
5352 IsStdInitListInitialization,
5353 ConstructorInitRequiresZeroInit,
5354 ConstructKind,
5355 ParenOrBraceRange);
5356 else
5357 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5358 Constructor,
5359 ConstructorArgs,
5360 HadMultipleCandidates,
5361 IsListInitialization,
5362 IsStdInitListInitialization,
5363 ConstructorInitRequiresZeroInit,
5364 ConstructKind,
5365 ParenOrBraceRange);
5366 }
5367 if (CurInit.isInvalid())
5368 return ExprError();
5369
5370 // Only check access if all of that succeeded.
5371 S.CheckConstructorAccess(Loc, Constructor, Entity,
5372 Step.Function.FoundDecl.getAccess());
5373 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5374 return ExprError();
5375
5376 if (shouldBindAsTemporary(Entity))
5377 CurInit = S.MaybeBindToTemporary(CurInit.get());
5378
5379 return CurInit;
5380 }
5381
5382 /// Determine whether the specified InitializedEntity definitely has a lifetime
5383 /// longer than the current full-expression. Conservatively returns false if
5384 /// it's unclear.
5385 static bool
InitializedEntityOutlivesFullExpression(const InitializedEntity & Entity)5386 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5387 const InitializedEntity *Top = &Entity;
5388 while (Top->getParent())
5389 Top = Top->getParent();
5390
5391 switch (Top->getKind()) {
5392 case InitializedEntity::EK_Variable:
5393 case InitializedEntity::EK_Result:
5394 case InitializedEntity::EK_Exception:
5395 case InitializedEntity::EK_Member:
5396 case InitializedEntity::EK_New:
5397 case InitializedEntity::EK_Base:
5398 case InitializedEntity::EK_Delegating:
5399 return true;
5400
5401 case InitializedEntity::EK_ArrayElement:
5402 case InitializedEntity::EK_VectorElement:
5403 case InitializedEntity::EK_BlockElement:
5404 case InitializedEntity::EK_ComplexElement:
5405 // Could not determine what the full initialization is. Assume it might not
5406 // outlive the full-expression.
5407 return false;
5408
5409 case InitializedEntity::EK_Parameter:
5410 case InitializedEntity::EK_Parameter_CF_Audited:
5411 case InitializedEntity::EK_Temporary:
5412 case InitializedEntity::EK_LambdaCapture:
5413 case InitializedEntity::EK_CompoundLiteralInit:
5414 case InitializedEntity::EK_RelatedResult:
5415 // The entity being initialized might not outlive the full-expression.
5416 return false;
5417 }
5418
5419 llvm_unreachable("unknown entity kind");
5420 }
5421
5422 /// Determine the declaration which an initialized entity ultimately refers to,
5423 /// for the purpose of lifetime-extending a temporary bound to a reference in
5424 /// the initialization of \p Entity.
getEntityForTemporaryLifetimeExtension(const InitializedEntity * Entity,const InitializedEntity * FallbackDecl=nullptr)5425 static const InitializedEntity *getEntityForTemporaryLifetimeExtension(
5426 const InitializedEntity *Entity,
5427 const InitializedEntity *FallbackDecl = nullptr) {
5428 // C++11 [class.temporary]p5:
5429 switch (Entity->getKind()) {
5430 case InitializedEntity::EK_Variable:
5431 // The temporary [...] persists for the lifetime of the reference
5432 return Entity;
5433
5434 case InitializedEntity::EK_Member:
5435 // For subobjects, we look at the complete object.
5436 if (Entity->getParent())
5437 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5438 Entity);
5439
5440 // except:
5441 // -- A temporary bound to a reference member in a constructor's
5442 // ctor-initializer persists until the constructor exits.
5443 return Entity;
5444
5445 case InitializedEntity::EK_Parameter:
5446 case InitializedEntity::EK_Parameter_CF_Audited:
5447 // -- A temporary bound to a reference parameter in a function call
5448 // persists until the completion of the full-expression containing
5449 // the call.
5450 case InitializedEntity::EK_Result:
5451 // -- The lifetime of a temporary bound to the returned value in a
5452 // function return statement is not extended; the temporary is
5453 // destroyed at the end of the full-expression in the return statement.
5454 case InitializedEntity::EK_New:
5455 // -- A temporary bound to a reference in a new-initializer persists
5456 // until the completion of the full-expression containing the
5457 // new-initializer.
5458 return nullptr;
5459
5460 case InitializedEntity::EK_Temporary:
5461 case InitializedEntity::EK_CompoundLiteralInit:
5462 case InitializedEntity::EK_RelatedResult:
5463 // We don't yet know the storage duration of the surrounding temporary.
5464 // Assume it's got full-expression duration for now, it will patch up our
5465 // storage duration if that's not correct.
5466 return nullptr;
5467
5468 case InitializedEntity::EK_ArrayElement:
5469 // For subobjects, we look at the complete object.
5470 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5471 FallbackDecl);
5472
5473 case InitializedEntity::EK_Base:
5474 case InitializedEntity::EK_Delegating:
5475 // We can reach this case for aggregate initialization in a constructor:
5476 // struct A { int &&r; };
5477 // struct B : A { B() : A{0} {} };
5478 // In this case, use the innermost field decl as the context.
5479 return FallbackDecl;
5480
5481 case InitializedEntity::EK_BlockElement:
5482 case InitializedEntity::EK_LambdaCapture:
5483 case InitializedEntity::EK_Exception:
5484 case InitializedEntity::EK_VectorElement:
5485 case InitializedEntity::EK_ComplexElement:
5486 return nullptr;
5487 }
5488 llvm_unreachable("unknown entity kind");
5489 }
5490
5491 static void performLifetimeExtension(Expr *Init,
5492 const InitializedEntity *ExtendingEntity);
5493
5494 /// Update a glvalue expression that is used as the initializer of a reference
5495 /// to note that its lifetime is extended.
5496 /// \return \c true if any temporary had its lifetime extended.
5497 static bool
performReferenceExtension(Expr * Init,const InitializedEntity * ExtendingEntity)5498 performReferenceExtension(Expr *Init,
5499 const InitializedEntity *ExtendingEntity) {
5500 // Walk past any constructs which we can lifetime-extend across.
5501 Expr *Old;
5502 do {
5503 Old = Init;
5504
5505 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5506 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5507 // This is just redundant braces around an initializer. Step over it.
5508 Init = ILE->getInit(0);
5509 }
5510 }
5511
5512 // Step over any subobject adjustments; we may have a materialized
5513 // temporary inside them.
5514 SmallVector<const Expr *, 2> CommaLHSs;
5515 SmallVector<SubobjectAdjustment, 2> Adjustments;
5516 Init = const_cast<Expr *>(
5517 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5518
5519 // Per current approach for DR1376, look through casts to reference type
5520 // when performing lifetime extension.
5521 if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5522 if (CE->getSubExpr()->isGLValue())
5523 Init = CE->getSubExpr();
5524
5525 // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5526 // It's unclear if binding a reference to that xvalue extends the array
5527 // temporary.
5528 } while (Init != Old);
5529
5530 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5531 // Update the storage duration of the materialized temporary.
5532 // FIXME: Rebuild the expression instead of mutating it.
5533 ME->setExtendingDecl(ExtendingEntity->getDecl(),
5534 ExtendingEntity->allocateManglingNumber());
5535 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
5536 return true;
5537 }
5538
5539 return false;
5540 }
5541
5542 /// Update a prvalue expression that is going to be materialized as a
5543 /// lifetime-extended temporary.
performLifetimeExtension(Expr * Init,const InitializedEntity * ExtendingEntity)5544 static void performLifetimeExtension(Expr *Init,
5545 const InitializedEntity *ExtendingEntity) {
5546 // Dig out the expression which constructs the extended temporary.
5547 SmallVector<const Expr *, 2> CommaLHSs;
5548 SmallVector<SubobjectAdjustment, 2> Adjustments;
5549 Init = const_cast<Expr *>(
5550 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5551
5552 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5553 Init = BTE->getSubExpr();
5554
5555 if (CXXStdInitializerListExpr *ILE =
5556 dyn_cast<CXXStdInitializerListExpr>(Init)) {
5557 performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
5558 return;
5559 }
5560
5561 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5562 if (ILE->getType()->isArrayType()) {
5563 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5564 performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
5565 return;
5566 }
5567
5568 if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
5569 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5570
5571 // If we lifetime-extend a braced initializer which is initializing an
5572 // aggregate, and that aggregate contains reference members which are
5573 // bound to temporaries, those temporaries are also lifetime-extended.
5574 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5575 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5576 performReferenceExtension(ILE->getInit(0), ExtendingEntity);
5577 else {
5578 unsigned Index = 0;
5579 for (const auto *I : RD->fields()) {
5580 if (Index >= ILE->getNumInits())
5581 break;
5582 if (I->isUnnamedBitfield())
5583 continue;
5584 Expr *SubInit = ILE->getInit(Index);
5585 if (I->getType()->isReferenceType())
5586 performReferenceExtension(SubInit, ExtendingEntity);
5587 else if (isa<InitListExpr>(SubInit) ||
5588 isa<CXXStdInitializerListExpr>(SubInit))
5589 // This may be either aggregate-initialization of a member or
5590 // initialization of a std::initializer_list object. Either way,
5591 // we should recursively lifetime-extend that initializer.
5592 performLifetimeExtension(SubInit, ExtendingEntity);
5593 ++Index;
5594 }
5595 }
5596 }
5597 }
5598 }
5599
warnOnLifetimeExtension(Sema & S,const InitializedEntity & Entity,const Expr * Init,bool IsInitializerList,const ValueDecl * ExtendingDecl)5600 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5601 const Expr *Init, bool IsInitializerList,
5602 const ValueDecl *ExtendingDecl) {
5603 // Warn if a field lifetime-extends a temporary.
5604 if (isa<FieldDecl>(ExtendingDecl)) {
5605 if (IsInitializerList) {
5606 S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5607 << /*at end of constructor*/true;
5608 return;
5609 }
5610
5611 bool IsSubobjectMember = false;
5612 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5613 Ent = Ent->getParent()) {
5614 if (Ent->getKind() != InitializedEntity::EK_Base) {
5615 IsSubobjectMember = true;
5616 break;
5617 }
5618 }
5619 S.Diag(Init->getExprLoc(),
5620 diag::warn_bind_ref_member_to_temporary)
5621 << ExtendingDecl << Init->getSourceRange()
5622 << IsSubobjectMember << IsInitializerList;
5623 if (IsSubobjectMember)
5624 S.Diag(ExtendingDecl->getLocation(),
5625 diag::note_ref_subobject_of_member_declared_here);
5626 else
5627 S.Diag(ExtendingDecl->getLocation(),
5628 diag::note_ref_or_ptr_member_declared_here)
5629 << /*is pointer*/false;
5630 }
5631 }
5632
5633 static void DiagnoseNarrowingInInitList(Sema &S,
5634 const ImplicitConversionSequence &ICS,
5635 QualType PreNarrowingType,
5636 QualType EntityType,
5637 const Expr *PostInit);
5638
5639 ExprResult
Perform(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,MultiExprArg Args,QualType * ResultType)5640 InitializationSequence::Perform(Sema &S,
5641 const InitializedEntity &Entity,
5642 const InitializationKind &Kind,
5643 MultiExprArg Args,
5644 QualType *ResultType) {
5645 if (Failed()) {
5646 Diagnose(S, Entity, Kind, Args);
5647 return ExprError();
5648 }
5649
5650 if (getKind() == DependentSequence) {
5651 // If the declaration is a non-dependent, incomplete array type
5652 // that has an initializer, then its type will be completed once
5653 // the initializer is instantiated.
5654 if (ResultType && !Entity.getType()->isDependentType() &&
5655 Args.size() == 1) {
5656 QualType DeclType = Entity.getType();
5657 if (const IncompleteArrayType *ArrayT
5658 = S.Context.getAsIncompleteArrayType(DeclType)) {
5659 // FIXME: We don't currently have the ability to accurately
5660 // compute the length of an initializer list without
5661 // performing full type-checking of the initializer list
5662 // (since we have to determine where braces are implicitly
5663 // introduced and such). So, we fall back to making the array
5664 // type a dependently-sized array type with no specified
5665 // bound.
5666 if (isa<InitListExpr>((Expr *)Args[0])) {
5667 SourceRange Brackets;
5668
5669 // Scavange the location of the brackets from the entity, if we can.
5670 if (DeclaratorDecl *DD = Entity.getDecl()) {
5671 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
5672 TypeLoc TL = TInfo->getTypeLoc();
5673 if (IncompleteArrayTypeLoc ArrayLoc =
5674 TL.getAs<IncompleteArrayTypeLoc>())
5675 Brackets = ArrayLoc.getBracketsRange();
5676 }
5677 }
5678
5679 *ResultType
5680 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
5681 /*NumElts=*/nullptr,
5682 ArrayT->getSizeModifier(),
5683 ArrayT->getIndexTypeCVRQualifiers(),
5684 Brackets);
5685 }
5686
5687 }
5688 }
5689 if (Kind.getKind() == InitializationKind::IK_Direct &&
5690 !Kind.isExplicitCast()) {
5691 // Rebuild the ParenListExpr.
5692 SourceRange ParenRange = Kind.getParenRange();
5693 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
5694 Args);
5695 }
5696 assert(Kind.getKind() == InitializationKind::IK_Copy ||
5697 Kind.isExplicitCast() ||
5698 Kind.getKind() == InitializationKind::IK_DirectList);
5699 return ExprResult(Args[0]);
5700 }
5701
5702 // No steps means no initialization.
5703 if (Steps.empty())
5704 return ExprResult((Expr *)nullptr);
5705
5706 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
5707 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
5708 !Entity.isParameterKind()) {
5709 // Produce a C++98 compatibility warning if we are initializing a reference
5710 // from an initializer list. For parameters, we produce a better warning
5711 // elsewhere.
5712 Expr *Init = Args[0];
5713 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
5714 << Init->getSourceRange();
5715 }
5716
5717 // Diagnose cases where we initialize a pointer to an array temporary, and the
5718 // pointer obviously outlives the temporary.
5719 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
5720 Entity.getType()->isPointerType() &&
5721 InitializedEntityOutlivesFullExpression(Entity)) {
5722 Expr *Init = Args[0];
5723 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
5724 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
5725 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
5726 << Init->getSourceRange();
5727 }
5728
5729 QualType DestType = Entity.getType().getNonReferenceType();
5730 // FIXME: Ugly hack around the fact that Entity.getType() is not
5731 // the same as Entity.getDecl()->getType() in cases involving type merging,
5732 // and we want latter when it makes sense.
5733 if (ResultType)
5734 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
5735 Entity.getType();
5736
5737 ExprResult CurInit((Expr *)nullptr);
5738
5739 // For initialization steps that start with a single initializer,
5740 // grab the only argument out the Args and place it into the "current"
5741 // initializer.
5742 switch (Steps.front().Kind) {
5743 case SK_ResolveAddressOfOverloadedFunction:
5744 case SK_CastDerivedToBaseRValue:
5745 case SK_CastDerivedToBaseXValue:
5746 case SK_CastDerivedToBaseLValue:
5747 case SK_BindReference:
5748 case SK_BindReferenceToTemporary:
5749 case SK_ExtraneousCopyToTemporary:
5750 case SK_UserConversion:
5751 case SK_QualificationConversionLValue:
5752 case SK_QualificationConversionXValue:
5753 case SK_QualificationConversionRValue:
5754 case SK_AtomicConversion:
5755 case SK_LValueToRValue:
5756 case SK_ConversionSequence:
5757 case SK_ConversionSequenceNoNarrowing:
5758 case SK_ListInitialization:
5759 case SK_UnwrapInitList:
5760 case SK_RewrapInitList:
5761 case SK_CAssignment:
5762 case SK_StringInit:
5763 case SK_ObjCObjectConversion:
5764 case SK_ArrayInit:
5765 case SK_ParenthesizedArrayInit:
5766 case SK_PassByIndirectCopyRestore:
5767 case SK_PassByIndirectRestore:
5768 case SK_ProduceObjCObject:
5769 case SK_StdInitializerList:
5770 case SK_OCLSamplerInit:
5771 case SK_OCLZeroEvent: {
5772 assert(Args.size() == 1);
5773 CurInit = Args[0];
5774 if (!CurInit.get()) return ExprError();
5775 break;
5776 }
5777
5778 case SK_ConstructorInitialization:
5779 case SK_ConstructorInitializationFromList:
5780 case SK_StdInitializerListConstructorCall:
5781 case SK_ZeroInitialization:
5782 break;
5783 }
5784
5785 // Walk through the computed steps for the initialization sequence,
5786 // performing the specified conversions along the way.
5787 bool ConstructorInitRequiresZeroInit = false;
5788 for (step_iterator Step = step_begin(), StepEnd = step_end();
5789 Step != StepEnd; ++Step) {
5790 if (CurInit.isInvalid())
5791 return ExprError();
5792
5793 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
5794
5795 switch (Step->Kind) {
5796 case SK_ResolveAddressOfOverloadedFunction:
5797 // Overload resolution determined which function invoke; update the
5798 // initializer to reflect that choice.
5799 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
5800 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
5801 return ExprError();
5802 CurInit = S.FixOverloadedFunctionReference(CurInit,
5803 Step->Function.FoundDecl,
5804 Step->Function.Function);
5805 break;
5806
5807 case SK_CastDerivedToBaseRValue:
5808 case SK_CastDerivedToBaseXValue:
5809 case SK_CastDerivedToBaseLValue: {
5810 // We have a derived-to-base cast that produces either an rvalue or an
5811 // lvalue. Perform that cast.
5812
5813 CXXCastPath BasePath;
5814
5815 // Casts to inaccessible base classes are allowed with C-style casts.
5816 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
5817 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
5818 CurInit.get()->getLocStart(),
5819 CurInit.get()->getSourceRange(),
5820 &BasePath, IgnoreBaseAccess))
5821 return ExprError();
5822
5823 if (S.BasePathInvolvesVirtualBase(BasePath)) {
5824 QualType T = SourceType;
5825 if (const PointerType *Pointer = T->getAs<PointerType>())
5826 T = Pointer->getPointeeType();
5827 if (const RecordType *RecordTy = T->getAs<RecordType>())
5828 S.MarkVTableUsed(CurInit.get()->getLocStart(),
5829 cast<CXXRecordDecl>(RecordTy->getDecl()));
5830 }
5831
5832 ExprValueKind VK =
5833 Step->Kind == SK_CastDerivedToBaseLValue ?
5834 VK_LValue :
5835 (Step->Kind == SK_CastDerivedToBaseXValue ?
5836 VK_XValue :
5837 VK_RValue);
5838 CurInit =
5839 ImplicitCastExpr::Create(S.Context, Step->Type, CK_DerivedToBase,
5840 CurInit.get(), &BasePath, VK);
5841 break;
5842 }
5843
5844 case SK_BindReference:
5845 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
5846 if (CurInit.get()->refersToBitField()) {
5847 // We don't necessarily have an unambiguous source bit-field.
5848 FieldDecl *BitField = CurInit.get()->getSourceBitField();
5849 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
5850 << Entity.getType().isVolatileQualified()
5851 << (BitField ? BitField->getDeclName() : DeclarationName())
5852 << (BitField != nullptr)
5853 << CurInit.get()->getSourceRange();
5854 if (BitField)
5855 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
5856
5857 return ExprError();
5858 }
5859
5860 if (CurInit.get()->refersToVectorElement()) {
5861 // References cannot bind to vector elements.
5862 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5863 << Entity.getType().isVolatileQualified()
5864 << CurInit.get()->getSourceRange();
5865 PrintInitLocationNote(S, Entity);
5866 return ExprError();
5867 }
5868
5869 // Reference binding does not have any corresponding ASTs.
5870
5871 // Check exception specifications
5872 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
5873 return ExprError();
5874
5875 // Even though we didn't materialize a temporary, the binding may still
5876 // extend the lifetime of a temporary. This happens if we bind a reference
5877 // to the result of a cast to reference type.
5878 if (const InitializedEntity *ExtendingEntity =
5879 getEntityForTemporaryLifetimeExtension(&Entity))
5880 if (performReferenceExtension(CurInit.get(), ExtendingEntity))
5881 warnOnLifetimeExtension(S, Entity, CurInit.get(),
5882 /*IsInitializerList=*/false,
5883 ExtendingEntity->getDecl());
5884
5885 break;
5886
5887 case SK_BindReferenceToTemporary: {
5888 // Make sure the "temporary" is actually an rvalue.
5889 assert(CurInit.get()->isRValue() && "not a temporary");
5890
5891 // Check exception specifications
5892 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
5893 return ExprError();
5894
5895 // Materialize the temporary into memory.
5896 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
5897 Entity.getType().getNonReferenceType(), CurInit.get(),
5898 Entity.getType()->isLValueReferenceType());
5899
5900 // Maybe lifetime-extend the temporary's subobjects to match the
5901 // entity's lifetime.
5902 if (const InitializedEntity *ExtendingEntity =
5903 getEntityForTemporaryLifetimeExtension(&Entity))
5904 if (performReferenceExtension(MTE, ExtendingEntity))
5905 warnOnLifetimeExtension(S, Entity, CurInit.get(), /*IsInitializerList=*/false,
5906 ExtendingEntity->getDecl());
5907
5908 // If we're binding to an Objective-C object that has lifetime, we
5909 // need cleanups. Likewise if we're extending this temporary to automatic
5910 // storage duration -- we need to register its cleanup during the
5911 // full-expression's cleanups.
5912 if ((S.getLangOpts().ObjCAutoRefCount &&
5913 MTE->getType()->isObjCLifetimeType()) ||
5914 (MTE->getStorageDuration() == SD_Automatic &&
5915 MTE->getType().isDestructedType()))
5916 S.ExprNeedsCleanups = true;
5917
5918 CurInit = MTE;
5919 break;
5920 }
5921
5922 case SK_ExtraneousCopyToTemporary:
5923 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
5924 /*IsExtraneousCopy=*/true);
5925 break;
5926
5927 case SK_UserConversion: {
5928 // We have a user-defined conversion that invokes either a constructor
5929 // or a conversion function.
5930 CastKind CastKind;
5931 bool IsCopy = false;
5932 FunctionDecl *Fn = Step->Function.Function;
5933 DeclAccessPair FoundFn = Step->Function.FoundDecl;
5934 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
5935 bool CreatedObject = false;
5936 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
5937 // Build a call to the selected constructor.
5938 SmallVector<Expr*, 8> ConstructorArgs;
5939 SourceLocation Loc = CurInit.get()->getLocStart();
5940 CurInit.get(); // Ownership transferred into MultiExprArg, below.
5941
5942 // Determine the arguments required to actually perform the constructor
5943 // call.
5944 Expr *Arg = CurInit.get();
5945 if (S.CompleteConstructorCall(Constructor,
5946 MultiExprArg(&Arg, 1),
5947 Loc, ConstructorArgs))
5948 return ExprError();
5949
5950 // Build an expression that constructs a temporary.
5951 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
5952 ConstructorArgs,
5953 HadMultipleCandidates,
5954 /*ListInit*/ false,
5955 /*StdInitListInit*/ false,
5956 /*ZeroInit*/ false,
5957 CXXConstructExpr::CK_Complete,
5958 SourceRange());
5959 if (CurInit.isInvalid())
5960 return ExprError();
5961
5962 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
5963 FoundFn.getAccess());
5964 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5965 return ExprError();
5966
5967 CastKind = CK_ConstructorConversion;
5968 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5969 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5970 S.IsDerivedFrom(SourceType, Class))
5971 IsCopy = true;
5972
5973 CreatedObject = true;
5974 } else {
5975 // Build a call to the conversion function.
5976 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
5977 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
5978 FoundFn);
5979 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5980 return ExprError();
5981
5982 // FIXME: Should we move this initialization into a separate
5983 // derived-to-base conversion? I believe the answer is "no", because
5984 // we don't want to turn off access control here for c-style casts.
5985 ExprResult CurInitExprRes =
5986 S.PerformObjectArgumentInitialization(CurInit.get(),
5987 /*Qualifier=*/nullptr,
5988 FoundFn, Conversion);
5989 if(CurInitExprRes.isInvalid())
5990 return ExprError();
5991 CurInit = CurInitExprRes;
5992
5993 // Build the actual call to the conversion function.
5994 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5995 HadMultipleCandidates);
5996 if (CurInit.isInvalid() || !CurInit.get())
5997 return ExprError();
5998
5999 CastKind = CK_UserDefinedConversion;
6000
6001 CreatedObject = Conversion->getReturnType()->isRecordType();
6002 }
6003
6004 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
6005 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
6006
6007 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
6008 QualType T = CurInit.get()->getType();
6009 if (const RecordType *Record = T->getAs<RecordType>()) {
6010 CXXDestructorDecl *Destructor
6011 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6012 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6013 S.PDiag(diag::err_access_dtor_temp) << T);
6014 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6015 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6016 return ExprError();
6017 }
6018 }
6019
6020 CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6021 CastKind, CurInit.get(), nullptr,
6022 CurInit.get()->getValueKind());
6023 if (MaybeBindToTemp)
6024 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6025 if (RequiresCopy)
6026 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
6027 CurInit, /*IsExtraneousCopy=*/false);
6028 break;
6029 }
6030
6031 case SK_QualificationConversionLValue:
6032 case SK_QualificationConversionXValue:
6033 case SK_QualificationConversionRValue: {
6034 // Perform a qualification conversion; these can never go wrong.
6035 ExprValueKind VK =
6036 Step->Kind == SK_QualificationConversionLValue ?
6037 VK_LValue :
6038 (Step->Kind == SK_QualificationConversionXValue ?
6039 VK_XValue :
6040 VK_RValue);
6041 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6042 break;
6043 }
6044
6045 case SK_AtomicConversion: {
6046 assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6047 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6048 CK_NonAtomicToAtomic, VK_RValue);
6049 break;
6050 }
6051
6052 case SK_LValueToRValue: {
6053 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6054 CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6055 CK_LValueToRValue, CurInit.get(),
6056 /*BasePath=*/nullptr, VK_RValue);
6057 break;
6058 }
6059
6060 case SK_ConversionSequence:
6061 case SK_ConversionSequenceNoNarrowing: {
6062 Sema::CheckedConversionKind CCK
6063 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
6064 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
6065 : Kind.isExplicitCast()? Sema::CCK_OtherCast
6066 : Sema::CCK_ImplicitConversion;
6067 ExprResult CurInitExprRes =
6068 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6069 getAssignmentAction(Entity), CCK);
6070 if (CurInitExprRes.isInvalid())
6071 return ExprError();
6072 CurInit = CurInitExprRes;
6073
6074 if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
6075 S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
6076 DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6077 CurInit.get());
6078 break;
6079 }
6080
6081 case SK_ListInitialization: {
6082 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6083 // If we're not initializing the top-level entity, we need to create an
6084 // InitializeTemporary entity for our target type.
6085 QualType Ty = Step->Type;
6086 bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6087 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
6088 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6089 InitListChecker PerformInitList(S, InitEntity,
6090 InitList, Ty, /*VerifyOnly=*/false);
6091 if (PerformInitList.HadError())
6092 return ExprError();
6093
6094 // Hack: We must update *ResultType if available in order to set the
6095 // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6096 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6097 if (ResultType &&
6098 ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6099 if ((*ResultType)->isRValueReferenceType())
6100 Ty = S.Context.getRValueReferenceType(Ty);
6101 else if ((*ResultType)->isLValueReferenceType())
6102 Ty = S.Context.getLValueReferenceType(Ty,
6103 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6104 *ResultType = Ty;
6105 }
6106
6107 InitListExpr *StructuredInitList =
6108 PerformInitList.getFullyStructuredList();
6109 CurInit.get();
6110 CurInit = shouldBindAsTemporary(InitEntity)
6111 ? S.MaybeBindToTemporary(StructuredInitList)
6112 : StructuredInitList;
6113 break;
6114 }
6115
6116 case SK_ConstructorInitializationFromList: {
6117 // When an initializer list is passed for a parameter of type "reference
6118 // to object", we don't get an EK_Temporary entity, but instead an
6119 // EK_Parameter entity with reference type.
6120 // FIXME: This is a hack. What we really should do is create a user
6121 // conversion step for this case, but this makes it considerably more
6122 // complicated. For now, this will do.
6123 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6124 Entity.getType().getNonReferenceType());
6125 bool UseTemporary = Entity.getType()->isReferenceType();
6126 assert(Args.size() == 1 && "expected a single argument for list init");
6127 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6128 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6129 << InitList->getSourceRange();
6130 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6131 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6132 Entity,
6133 Kind, Arg, *Step,
6134 ConstructorInitRequiresZeroInit,
6135 /*IsListInitialization*/true,
6136 /*IsStdInitListInit*/false,
6137 InitList->getLBraceLoc(),
6138 InitList->getRBraceLoc());
6139 break;
6140 }
6141
6142 case SK_UnwrapInitList:
6143 CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6144 break;
6145
6146 case SK_RewrapInitList: {
6147 Expr *E = CurInit.get();
6148 InitListExpr *Syntactic = Step->WrappingSyntacticList;
6149 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6150 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6151 ILE->setSyntacticForm(Syntactic);
6152 ILE->setType(E->getType());
6153 ILE->setValueKind(E->getValueKind());
6154 CurInit = ILE;
6155 break;
6156 }
6157
6158 case SK_ConstructorInitialization:
6159 case SK_StdInitializerListConstructorCall: {
6160 // When an initializer list is passed for a parameter of type "reference
6161 // to object", we don't get an EK_Temporary entity, but instead an
6162 // EK_Parameter entity with reference type.
6163 // FIXME: This is a hack. What we really should do is create a user
6164 // conversion step for this case, but this makes it considerably more
6165 // complicated. For now, this will do.
6166 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6167 Entity.getType().getNonReferenceType());
6168 bool UseTemporary = Entity.getType()->isReferenceType();
6169 bool IsStdInitListInit =
6170 Step->Kind == SK_StdInitializerListConstructorCall;
6171 CurInit = PerformConstructorInitialization(
6172 S, UseTemporary ? TempEntity : Entity, Kind, Args, *Step,
6173 ConstructorInitRequiresZeroInit,
6174 /*IsListInitialization*/IsStdInitListInit,
6175 /*IsStdInitListInitialization*/IsStdInitListInit,
6176 /*LBraceLoc*/SourceLocation(),
6177 /*RBraceLoc*/SourceLocation());
6178 break;
6179 }
6180
6181 case SK_ZeroInitialization: {
6182 step_iterator NextStep = Step;
6183 ++NextStep;
6184 if (NextStep != StepEnd &&
6185 (NextStep->Kind == SK_ConstructorInitialization ||
6186 NextStep->Kind == SK_ConstructorInitializationFromList)) {
6187 // The need for zero-initialization is recorded directly into
6188 // the call to the object's constructor within the next step.
6189 ConstructorInitRequiresZeroInit = true;
6190 } else if (Kind.getKind() == InitializationKind::IK_Value &&
6191 S.getLangOpts().CPlusPlus &&
6192 !Kind.isImplicitValueInit()) {
6193 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6194 if (!TSInfo)
6195 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
6196 Kind.getRange().getBegin());
6197
6198 CurInit = new (S.Context) CXXScalarValueInitExpr(
6199 TSInfo->getType().getNonLValueExprType(S.Context), TSInfo,
6200 Kind.getRange().getEnd());
6201 } else {
6202 CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
6203 }
6204 break;
6205 }
6206
6207 case SK_CAssignment: {
6208 QualType SourceType = CurInit.get()->getType();
6209 ExprResult Result = CurInit;
6210 Sema::AssignConvertType ConvTy =
6211 S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6212 Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
6213 if (Result.isInvalid())
6214 return ExprError();
6215 CurInit = Result;
6216
6217 // If this is a call, allow conversion to a transparent union.
6218 ExprResult CurInitExprRes = CurInit;
6219 if (ConvTy != Sema::Compatible &&
6220 Entity.isParameterKind() &&
6221 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
6222 == Sema::Compatible)
6223 ConvTy = Sema::Compatible;
6224 if (CurInitExprRes.isInvalid())
6225 return ExprError();
6226 CurInit = CurInitExprRes;
6227
6228 bool Complained;
6229 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6230 Step->Type, SourceType,
6231 CurInit.get(),
6232 getAssignmentAction(Entity, true),
6233 &Complained)) {
6234 PrintInitLocationNote(S, Entity);
6235 return ExprError();
6236 } else if (Complained)
6237 PrintInitLocationNote(S, Entity);
6238 break;
6239 }
6240
6241 case SK_StringInit: {
6242 QualType Ty = Step->Type;
6243 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
6244 S.Context.getAsArrayType(Ty), S);
6245 break;
6246 }
6247
6248 case SK_ObjCObjectConversion:
6249 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6250 CK_ObjCObjectLValueCast,
6251 CurInit.get()->getValueKind());
6252 break;
6253
6254 case SK_ArrayInit:
6255 // Okay: we checked everything before creating this step. Note that
6256 // this is a GNU extension.
6257 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
6258 << Step->Type << CurInit.get()->getType()
6259 << CurInit.get()->getSourceRange();
6260
6261 // If the destination type is an incomplete array type, update the
6262 // type accordingly.
6263 if (ResultType) {
6264 if (const IncompleteArrayType *IncompleteDest
6265 = S.Context.getAsIncompleteArrayType(Step->Type)) {
6266 if (const ConstantArrayType *ConstantSource
6267 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
6268 *ResultType = S.Context.getConstantArrayType(
6269 IncompleteDest->getElementType(),
6270 ConstantSource->getSize(),
6271 ArrayType::Normal, 0);
6272 }
6273 }
6274 }
6275 break;
6276
6277 case SK_ParenthesizedArrayInit:
6278 // Okay: we checked everything before creating this step. Note that
6279 // this is a GNU extension.
6280 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6281 << CurInit.get()->getSourceRange();
6282 break;
6283
6284 case SK_PassByIndirectCopyRestore:
6285 case SK_PassByIndirectRestore:
6286 checkIndirectCopyRestoreSource(S, CurInit.get());
6287 CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
6288 CurInit.get(), Step->Type,
6289 Step->Kind == SK_PassByIndirectCopyRestore);
6290 break;
6291
6292 case SK_ProduceObjCObject:
6293 CurInit =
6294 ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject,
6295 CurInit.get(), nullptr, VK_RValue);
6296 break;
6297
6298 case SK_StdInitializerList: {
6299 S.Diag(CurInit.get()->getExprLoc(),
6300 diag::warn_cxx98_compat_initializer_list_init)
6301 << CurInit.get()->getSourceRange();
6302
6303 // Materialize the temporary into memory.
6304 MaterializeTemporaryExpr *MTE = new (S.Context)
6305 MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
6306 /*BoundToLvalueReference=*/false);
6307
6308 // Maybe lifetime-extend the array temporary's subobjects to match the
6309 // entity's lifetime.
6310 if (const InitializedEntity *ExtendingEntity =
6311 getEntityForTemporaryLifetimeExtension(&Entity))
6312 if (performReferenceExtension(MTE, ExtendingEntity))
6313 warnOnLifetimeExtension(S, Entity, CurInit.get(),
6314 /*IsInitializerList=*/true,
6315 ExtendingEntity->getDecl());
6316
6317 // Wrap it in a construction of a std::initializer_list<T>.
6318 CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
6319
6320 // Bind the result, in case the library has given initializer_list a
6321 // non-trivial destructor.
6322 if (shouldBindAsTemporary(Entity))
6323 CurInit = S.MaybeBindToTemporary(CurInit.get());
6324 break;
6325 }
6326
6327 case SK_OCLSamplerInit: {
6328 assert(Step->Type->isSamplerT() &&
6329 "Sampler initialization on non-sampler type.");
6330
6331 QualType SourceType = CurInit.get()->getType();
6332
6333 if (Entity.isParameterKind()) {
6334 if (!SourceType->isSamplerT())
6335 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6336 << SourceType;
6337 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
6338 llvm_unreachable("Invalid EntityKind!");
6339 }
6340
6341 break;
6342 }
6343 case SK_OCLZeroEvent: {
6344 assert(Step->Type->isEventT() &&
6345 "Event initialization on non-event type.");
6346
6347 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6348 CK_ZeroToOCLEvent,
6349 CurInit.get()->getValueKind());
6350 break;
6351 }
6352 }
6353 }
6354
6355 // Diagnose non-fatal problems with the completed initialization.
6356 if (Entity.getKind() == InitializedEntity::EK_Member &&
6357 cast<FieldDecl>(Entity.getDecl())->isBitField())
6358 S.CheckBitFieldInitialization(Kind.getLocation(),
6359 cast<FieldDecl>(Entity.getDecl()),
6360 CurInit.get());
6361
6362 return CurInit;
6363 }
6364
6365 /// Somewhere within T there is an uninitialized reference subobject.
6366 /// Dig it out and diagnose it.
DiagnoseUninitializedReference(Sema & S,SourceLocation Loc,QualType T)6367 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6368 QualType T) {
6369 if (T->isReferenceType()) {
6370 S.Diag(Loc, diag::err_reference_without_init)
6371 << T.getNonReferenceType();
6372 return true;
6373 }
6374
6375 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6376 if (!RD || !RD->hasUninitializedReferenceMember())
6377 return false;
6378
6379 for (const auto *FI : RD->fields()) {
6380 if (FI->isUnnamedBitfield())
6381 continue;
6382
6383 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6384 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6385 return true;
6386 }
6387 }
6388
6389 for (const auto &BI : RD->bases()) {
6390 if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
6391 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6392 return true;
6393 }
6394 }
6395
6396 return false;
6397 }
6398
6399
6400 //===----------------------------------------------------------------------===//
6401 // Diagnose initialization failures
6402 //===----------------------------------------------------------------------===//
6403
6404 /// Emit notes associated with an initialization that failed due to a
6405 /// "simple" conversion failure.
emitBadConversionNotes(Sema & S,const InitializedEntity & entity,Expr * op)6406 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6407 Expr *op) {
6408 QualType destType = entity.getType();
6409 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6410 op->getType()->isObjCObjectPointerType()) {
6411
6412 // Emit a possible note about the conversion failing because the
6413 // operand is a message send with a related result type.
6414 S.EmitRelatedResultTypeNote(op);
6415
6416 // Emit a possible note about a return failing because we're
6417 // expecting a related result type.
6418 if (entity.getKind() == InitializedEntity::EK_Result)
6419 S.EmitRelatedResultTypeNoteForReturn(destType);
6420 }
6421 }
6422
diagnoseListInit(Sema & S,const InitializedEntity & Entity,InitListExpr * InitList)6423 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6424 InitListExpr *InitList) {
6425 QualType DestType = Entity.getType();
6426
6427 QualType E;
6428 if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6429 QualType ArrayType = S.Context.getConstantArrayType(
6430 E.withConst(),
6431 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6432 InitList->getNumInits()),
6433 clang::ArrayType::Normal, 0);
6434 InitializedEntity HiddenArray =
6435 InitializedEntity::InitializeTemporary(ArrayType);
6436 return diagnoseListInit(S, HiddenArray, InitList);
6437 }
6438
6439 if (DestType->isReferenceType()) {
6440 // A list-initialization failure for a reference means that we tried to
6441 // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
6442 // inner initialization failed.
6443 QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
6444 diagnoseListInit(S, InitializedEntity::InitializeTemporary(T), InitList);
6445 SourceLocation Loc = InitList->getLocStart();
6446 if (auto *D = Entity.getDecl())
6447 Loc = D->getLocation();
6448 S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
6449 return;
6450 }
6451
6452 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6453 /*VerifyOnly=*/false);
6454 assert(DiagnoseInitList.HadError() &&
6455 "Inconsistent init list check result.");
6456 }
6457
6458 /// Prints a fixit for adding a null initializer for |Entity|. Call this only
6459 /// right after emitting a diagnostic.
maybeEmitZeroInitializationFixit(Sema & S,InitializationSequence & Sequence,const InitializedEntity & Entity)6460 static void maybeEmitZeroInitializationFixit(Sema &S,
6461 InitializationSequence &Sequence,
6462 const InitializedEntity &Entity) {
6463 if (Entity.getKind() != InitializedEntity::EK_Variable)
6464 return;
6465
6466 VarDecl *VD = cast<VarDecl>(Entity.getDecl());
6467 if (VD->getInit() || VD->getLocEnd().isMacroID())
6468 return;
6469
6470 QualType VariableTy = VD->getType().getCanonicalType();
6471 SourceLocation Loc = S.getLocForEndOfToken(VD->getLocEnd());
6472 std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
6473
6474 S.Diag(Loc, diag::note_add_initializer)
6475 << VD << FixItHint::CreateInsertion(Loc, Init);
6476 }
6477
Diagnose(Sema & S,const InitializedEntity & Entity,const InitializationKind & Kind,ArrayRef<Expr * > Args)6478 bool InitializationSequence::Diagnose(Sema &S,
6479 const InitializedEntity &Entity,
6480 const InitializationKind &Kind,
6481 ArrayRef<Expr *> Args) {
6482 if (!Failed())
6483 return false;
6484
6485 QualType DestType = Entity.getType();
6486 switch (Failure) {
6487 case FK_TooManyInitsForReference:
6488 // FIXME: Customize for the initialized entity?
6489 if (Args.empty()) {
6490 // Dig out the reference subobject which is uninitialized and diagnose it.
6491 // If this is value-initialization, this could be nested some way within
6492 // the target type.
6493 assert(Kind.getKind() == InitializationKind::IK_Value ||
6494 DestType->isReferenceType());
6495 bool Diagnosed =
6496 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6497 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6498 (void)Diagnosed;
6499 } else // FIXME: diagnostic below could be better!
6500 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
6501 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
6502 break;
6503
6504 case FK_ArrayNeedsInitList:
6505 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
6506 break;
6507 case FK_ArrayNeedsInitListOrStringLiteral:
6508 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6509 break;
6510 case FK_ArrayNeedsInitListOrWideStringLiteral:
6511 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6512 break;
6513 case FK_NarrowStringIntoWideCharArray:
6514 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6515 break;
6516 case FK_WideStringIntoCharArray:
6517 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6518 break;
6519 case FK_IncompatWideStringIntoWideChar:
6520 S.Diag(Kind.getLocation(),
6521 diag::err_array_init_incompat_wide_string_into_wchar);
6522 break;
6523 case FK_ArrayTypeMismatch:
6524 case FK_NonConstantArrayInit:
6525 S.Diag(Kind.getLocation(),
6526 (Failure == FK_ArrayTypeMismatch
6527 ? diag::err_array_init_different_type
6528 : diag::err_array_init_non_constant_array))
6529 << DestType.getNonReferenceType()
6530 << Args[0]->getType()
6531 << Args[0]->getSourceRange();
6532 break;
6533
6534 case FK_VariableLengthArrayHasInitializer:
6535 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6536 << Args[0]->getSourceRange();
6537 break;
6538
6539 case FK_AddressOfOverloadFailed: {
6540 DeclAccessPair Found;
6541 S.ResolveAddressOfOverloadedFunction(Args[0],
6542 DestType.getNonReferenceType(),
6543 true,
6544 Found);
6545 break;
6546 }
6547
6548 case FK_ReferenceInitOverloadFailed:
6549 case FK_UserConversionOverloadFailed:
6550 switch (FailedOverloadResult) {
6551 case OR_Ambiguous:
6552 if (Failure == FK_UserConversionOverloadFailed)
6553 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6554 << Args[0]->getType() << DestType
6555 << Args[0]->getSourceRange();
6556 else
6557 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6558 << DestType << Args[0]->getType()
6559 << Args[0]->getSourceRange();
6560
6561 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6562 break;
6563
6564 case OR_No_Viable_Function:
6565 if (!S.RequireCompleteType(Kind.getLocation(),
6566 DestType.getNonReferenceType(),
6567 diag::err_typecheck_nonviable_condition_incomplete,
6568 Args[0]->getType(), Args[0]->getSourceRange()))
6569 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6570 << Args[0]->getType() << Args[0]->getSourceRange()
6571 << DestType.getNonReferenceType();
6572
6573 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6574 break;
6575
6576 case OR_Deleted: {
6577 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6578 << Args[0]->getType() << DestType.getNonReferenceType()
6579 << Args[0]->getSourceRange();
6580 OverloadCandidateSet::iterator Best;
6581 OverloadingResult Ovl
6582 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6583 true);
6584 if (Ovl == OR_Deleted) {
6585 S.NoteDeletedFunction(Best->Function);
6586 } else {
6587 llvm_unreachable("Inconsistent overload resolution?");
6588 }
6589 break;
6590 }
6591
6592 case OR_Success:
6593 llvm_unreachable("Conversion did not fail!");
6594 }
6595 break;
6596
6597 case FK_NonConstLValueReferenceBindingToTemporary:
6598 if (isa<InitListExpr>(Args[0])) {
6599 S.Diag(Kind.getLocation(),
6600 diag::err_lvalue_reference_bind_to_initlist)
6601 << DestType.getNonReferenceType().isVolatileQualified()
6602 << DestType.getNonReferenceType()
6603 << Args[0]->getSourceRange();
6604 break;
6605 }
6606 // Intentional fallthrough
6607
6608 case FK_NonConstLValueReferenceBindingToUnrelated:
6609 S.Diag(Kind.getLocation(),
6610 Failure == FK_NonConstLValueReferenceBindingToTemporary
6611 ? diag::err_lvalue_reference_bind_to_temporary
6612 : diag::err_lvalue_reference_bind_to_unrelated)
6613 << DestType.getNonReferenceType().isVolatileQualified()
6614 << DestType.getNonReferenceType()
6615 << Args[0]->getType()
6616 << Args[0]->getSourceRange();
6617 break;
6618
6619 case FK_RValueReferenceBindingToLValue:
6620 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
6621 << DestType.getNonReferenceType() << Args[0]->getType()
6622 << Args[0]->getSourceRange();
6623 break;
6624
6625 case FK_ReferenceInitDropsQualifiers:
6626 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
6627 << DestType.getNonReferenceType()
6628 << Args[0]->getType()
6629 << Args[0]->getSourceRange();
6630 break;
6631
6632 case FK_ReferenceInitFailed:
6633 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
6634 << DestType.getNonReferenceType()
6635 << Args[0]->isLValue()
6636 << Args[0]->getType()
6637 << Args[0]->getSourceRange();
6638 emitBadConversionNotes(S, Entity, Args[0]);
6639 break;
6640
6641 case FK_ConversionFailed: {
6642 QualType FromType = Args[0]->getType();
6643 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
6644 << (int)Entity.getKind()
6645 << DestType
6646 << Args[0]->isLValue()
6647 << FromType
6648 << Args[0]->getSourceRange();
6649 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
6650 S.Diag(Kind.getLocation(), PDiag);
6651 emitBadConversionNotes(S, Entity, Args[0]);
6652 break;
6653 }
6654
6655 case FK_ConversionFromPropertyFailed:
6656 // No-op. This error has already been reported.
6657 break;
6658
6659 case FK_TooManyInitsForScalar: {
6660 SourceRange R;
6661
6662 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
6663 R = SourceRange(InitList->getInit(0)->getLocEnd(),
6664 InitList->getLocEnd());
6665 else
6666 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
6667
6668 R.setBegin(S.getLocForEndOfToken(R.getBegin()));
6669 if (Kind.isCStyleOrFunctionalCast())
6670 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
6671 << R;
6672 else
6673 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
6674 << /*scalar=*/2 << R;
6675 break;
6676 }
6677
6678 case FK_ReferenceBindingToInitList:
6679 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
6680 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
6681 break;
6682
6683 case FK_InitListBadDestinationType:
6684 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
6685 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
6686 break;
6687
6688 case FK_ListConstructorOverloadFailed:
6689 case FK_ConstructorOverloadFailed: {
6690 SourceRange ArgsRange;
6691 if (Args.size())
6692 ArgsRange = SourceRange(Args.front()->getLocStart(),
6693 Args.back()->getLocEnd());
6694
6695 if (Failure == FK_ListConstructorOverloadFailed) {
6696 assert(Args.size() == 1 &&
6697 "List construction from other than 1 argument.");
6698 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6699 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
6700 }
6701
6702 // FIXME: Using "DestType" for the entity we're printing is probably
6703 // bad.
6704 switch (FailedOverloadResult) {
6705 case OR_Ambiguous:
6706 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
6707 << DestType << ArgsRange;
6708 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6709 break;
6710
6711 case OR_No_Viable_Function:
6712 if (Kind.getKind() == InitializationKind::IK_Default &&
6713 (Entity.getKind() == InitializedEntity::EK_Base ||
6714 Entity.getKind() == InitializedEntity::EK_Member) &&
6715 isa<CXXConstructorDecl>(S.CurContext)) {
6716 // This is implicit default initialization of a member or
6717 // base within a constructor. If no viable function was
6718 // found, notify the user that she needs to explicitly
6719 // initialize this base/member.
6720 CXXConstructorDecl *Constructor
6721 = cast<CXXConstructorDecl>(S.CurContext);
6722 if (Entity.getKind() == InitializedEntity::EK_Base) {
6723 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
6724 << (Constructor->getInheritedConstructor() ? 2 :
6725 Constructor->isImplicit() ? 1 : 0)
6726 << S.Context.getTypeDeclType(Constructor->getParent())
6727 << /*base=*/0
6728 << Entity.getType();
6729
6730 RecordDecl *BaseDecl
6731 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
6732 ->getDecl();
6733 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
6734 << S.Context.getTagDeclType(BaseDecl);
6735 } else {
6736 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
6737 << (Constructor->getInheritedConstructor() ? 2 :
6738 Constructor->isImplicit() ? 1 : 0)
6739 << S.Context.getTypeDeclType(Constructor->getParent())
6740 << /*member=*/1
6741 << Entity.getName();
6742 S.Diag(Entity.getDecl()->getLocation(),
6743 diag::note_member_declared_at);
6744
6745 if (const RecordType *Record
6746 = Entity.getType()->getAs<RecordType>())
6747 S.Diag(Record->getDecl()->getLocation(),
6748 diag::note_previous_decl)
6749 << S.Context.getTagDeclType(Record->getDecl());
6750 }
6751 break;
6752 }
6753
6754 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
6755 << DestType << ArgsRange;
6756 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6757 break;
6758
6759 case OR_Deleted: {
6760 OverloadCandidateSet::iterator Best;
6761 OverloadingResult Ovl
6762 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
6763 if (Ovl != OR_Deleted) {
6764 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6765 << true << DestType << ArgsRange;
6766 llvm_unreachable("Inconsistent overload resolution?");
6767 break;
6768 }
6769
6770 // If this is a defaulted or implicitly-declared function, then
6771 // it was implicitly deleted. Make it clear that the deletion was
6772 // implicit.
6773 if (S.isImplicitlyDeleted(Best->Function))
6774 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
6775 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
6776 << DestType << ArgsRange;
6777 else
6778 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6779 << true << DestType << ArgsRange;
6780
6781 S.NoteDeletedFunction(Best->Function);
6782 break;
6783 }
6784
6785 case OR_Success:
6786 llvm_unreachable("Conversion did not fail!");
6787 }
6788 }
6789 break;
6790
6791 case FK_DefaultInitOfConst:
6792 if (Entity.getKind() == InitializedEntity::EK_Member &&
6793 isa<CXXConstructorDecl>(S.CurContext)) {
6794 // This is implicit default-initialization of a const member in
6795 // a constructor. Complain that it needs to be explicitly
6796 // initialized.
6797 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
6798 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
6799 << (Constructor->getInheritedConstructor() ? 2 :
6800 Constructor->isImplicit() ? 1 : 0)
6801 << S.Context.getTypeDeclType(Constructor->getParent())
6802 << /*const=*/1
6803 << Entity.getName();
6804 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
6805 << Entity.getName();
6806 } else {
6807 S.Diag(Kind.getLocation(), diag::err_default_init_const)
6808 << DestType << (bool)DestType->getAs<RecordType>();
6809 maybeEmitZeroInitializationFixit(S, *this, Entity);
6810 }
6811 break;
6812
6813 case FK_Incomplete:
6814 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
6815 diag::err_init_incomplete_type);
6816 break;
6817
6818 case FK_ListInitializationFailed: {
6819 // Run the init list checker again to emit diagnostics.
6820 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6821 diagnoseListInit(S, Entity, InitList);
6822 break;
6823 }
6824
6825 case FK_PlaceholderType: {
6826 // FIXME: Already diagnosed!
6827 break;
6828 }
6829
6830 case FK_ExplicitConstructor: {
6831 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
6832 << Args[0]->getSourceRange();
6833 OverloadCandidateSet::iterator Best;
6834 OverloadingResult Ovl
6835 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
6836 (void)Ovl;
6837 assert(Ovl == OR_Success && "Inconsistent overload resolution");
6838 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
6839 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
6840 break;
6841 }
6842 }
6843
6844 PrintInitLocationNote(S, Entity);
6845 return true;
6846 }
6847
dump(raw_ostream & OS) const6848 void InitializationSequence::dump(raw_ostream &OS) const {
6849 switch (SequenceKind) {
6850 case FailedSequence: {
6851 OS << "Failed sequence: ";
6852 switch (Failure) {
6853 case FK_TooManyInitsForReference:
6854 OS << "too many initializers for reference";
6855 break;
6856
6857 case FK_ArrayNeedsInitList:
6858 OS << "array requires initializer list";
6859 break;
6860
6861 case FK_ArrayNeedsInitListOrStringLiteral:
6862 OS << "array requires initializer list or string literal";
6863 break;
6864
6865 case FK_ArrayNeedsInitListOrWideStringLiteral:
6866 OS << "array requires initializer list or wide string literal";
6867 break;
6868
6869 case FK_NarrowStringIntoWideCharArray:
6870 OS << "narrow string into wide char array";
6871 break;
6872
6873 case FK_WideStringIntoCharArray:
6874 OS << "wide string into char array";
6875 break;
6876
6877 case FK_IncompatWideStringIntoWideChar:
6878 OS << "incompatible wide string into wide char array";
6879 break;
6880
6881 case FK_ArrayTypeMismatch:
6882 OS << "array type mismatch";
6883 break;
6884
6885 case FK_NonConstantArrayInit:
6886 OS << "non-constant array initializer";
6887 break;
6888
6889 case FK_AddressOfOverloadFailed:
6890 OS << "address of overloaded function failed";
6891 break;
6892
6893 case FK_ReferenceInitOverloadFailed:
6894 OS << "overload resolution for reference initialization failed";
6895 break;
6896
6897 case FK_NonConstLValueReferenceBindingToTemporary:
6898 OS << "non-const lvalue reference bound to temporary";
6899 break;
6900
6901 case FK_NonConstLValueReferenceBindingToUnrelated:
6902 OS << "non-const lvalue reference bound to unrelated type";
6903 break;
6904
6905 case FK_RValueReferenceBindingToLValue:
6906 OS << "rvalue reference bound to an lvalue";
6907 break;
6908
6909 case FK_ReferenceInitDropsQualifiers:
6910 OS << "reference initialization drops qualifiers";
6911 break;
6912
6913 case FK_ReferenceInitFailed:
6914 OS << "reference initialization failed";
6915 break;
6916
6917 case FK_ConversionFailed:
6918 OS << "conversion failed";
6919 break;
6920
6921 case FK_ConversionFromPropertyFailed:
6922 OS << "conversion from property failed";
6923 break;
6924
6925 case FK_TooManyInitsForScalar:
6926 OS << "too many initializers for scalar";
6927 break;
6928
6929 case FK_ReferenceBindingToInitList:
6930 OS << "referencing binding to initializer list";
6931 break;
6932
6933 case FK_InitListBadDestinationType:
6934 OS << "initializer list for non-aggregate, non-scalar type";
6935 break;
6936
6937 case FK_UserConversionOverloadFailed:
6938 OS << "overloading failed for user-defined conversion";
6939 break;
6940
6941 case FK_ConstructorOverloadFailed:
6942 OS << "constructor overloading failed";
6943 break;
6944
6945 case FK_DefaultInitOfConst:
6946 OS << "default initialization of a const variable";
6947 break;
6948
6949 case FK_Incomplete:
6950 OS << "initialization of incomplete type";
6951 break;
6952
6953 case FK_ListInitializationFailed:
6954 OS << "list initialization checker failure";
6955 break;
6956
6957 case FK_VariableLengthArrayHasInitializer:
6958 OS << "variable length array has an initializer";
6959 break;
6960
6961 case FK_PlaceholderType:
6962 OS << "initializer expression isn't contextually valid";
6963 break;
6964
6965 case FK_ListConstructorOverloadFailed:
6966 OS << "list constructor overloading failed";
6967 break;
6968
6969 case FK_ExplicitConstructor:
6970 OS << "list copy initialization chose explicit constructor";
6971 break;
6972 }
6973 OS << '\n';
6974 return;
6975 }
6976
6977 case DependentSequence:
6978 OS << "Dependent sequence\n";
6979 return;
6980
6981 case NormalSequence:
6982 OS << "Normal sequence: ";
6983 break;
6984 }
6985
6986 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6987 if (S != step_begin()) {
6988 OS << " -> ";
6989 }
6990
6991 switch (S->Kind) {
6992 case SK_ResolveAddressOfOverloadedFunction:
6993 OS << "resolve address of overloaded function";
6994 break;
6995
6996 case SK_CastDerivedToBaseRValue:
6997 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6998 break;
6999
7000 case SK_CastDerivedToBaseXValue:
7001 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
7002 break;
7003
7004 case SK_CastDerivedToBaseLValue:
7005 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
7006 break;
7007
7008 case SK_BindReference:
7009 OS << "bind reference to lvalue";
7010 break;
7011
7012 case SK_BindReferenceToTemporary:
7013 OS << "bind reference to a temporary";
7014 break;
7015
7016 case SK_ExtraneousCopyToTemporary:
7017 OS << "extraneous C++03 copy to temporary";
7018 break;
7019
7020 case SK_UserConversion:
7021 OS << "user-defined conversion via " << *S->Function.Function;
7022 break;
7023
7024 case SK_QualificationConversionRValue:
7025 OS << "qualification conversion (rvalue)";
7026 break;
7027
7028 case SK_QualificationConversionXValue:
7029 OS << "qualification conversion (xvalue)";
7030 break;
7031
7032 case SK_QualificationConversionLValue:
7033 OS << "qualification conversion (lvalue)";
7034 break;
7035
7036 case SK_AtomicConversion:
7037 OS << "non-atomic-to-atomic conversion";
7038 break;
7039
7040 case SK_LValueToRValue:
7041 OS << "load (lvalue to rvalue)";
7042 break;
7043
7044 case SK_ConversionSequence:
7045 OS << "implicit conversion sequence (";
7046 S->ICS->dump(); // FIXME: use OS
7047 OS << ")";
7048 break;
7049
7050 case SK_ConversionSequenceNoNarrowing:
7051 OS << "implicit conversion sequence with narrowing prohibited (";
7052 S->ICS->dump(); // FIXME: use OS
7053 OS << ")";
7054 break;
7055
7056 case SK_ListInitialization:
7057 OS << "list aggregate initialization";
7058 break;
7059
7060 case SK_UnwrapInitList:
7061 OS << "unwrap reference initializer list";
7062 break;
7063
7064 case SK_RewrapInitList:
7065 OS << "rewrap reference initializer list";
7066 break;
7067
7068 case SK_ConstructorInitialization:
7069 OS << "constructor initialization";
7070 break;
7071
7072 case SK_ConstructorInitializationFromList:
7073 OS << "list initialization via constructor";
7074 break;
7075
7076 case SK_ZeroInitialization:
7077 OS << "zero initialization";
7078 break;
7079
7080 case SK_CAssignment:
7081 OS << "C assignment";
7082 break;
7083
7084 case SK_StringInit:
7085 OS << "string initialization";
7086 break;
7087
7088 case SK_ObjCObjectConversion:
7089 OS << "Objective-C object conversion";
7090 break;
7091
7092 case SK_ArrayInit:
7093 OS << "array initialization";
7094 break;
7095
7096 case SK_ParenthesizedArrayInit:
7097 OS << "parenthesized array initialization";
7098 break;
7099
7100 case SK_PassByIndirectCopyRestore:
7101 OS << "pass by indirect copy and restore";
7102 break;
7103
7104 case SK_PassByIndirectRestore:
7105 OS << "pass by indirect restore";
7106 break;
7107
7108 case SK_ProduceObjCObject:
7109 OS << "Objective-C object retension";
7110 break;
7111
7112 case SK_StdInitializerList:
7113 OS << "std::initializer_list from initializer list";
7114 break;
7115
7116 case SK_StdInitializerListConstructorCall:
7117 OS << "list initialization from std::initializer_list";
7118 break;
7119
7120 case SK_OCLSamplerInit:
7121 OS << "OpenCL sampler_t from integer constant";
7122 break;
7123
7124 case SK_OCLZeroEvent:
7125 OS << "OpenCL event_t from zero";
7126 break;
7127 }
7128
7129 OS << " [" << S->Type.getAsString() << ']';
7130 }
7131
7132 OS << '\n';
7133 }
7134
dump() const7135 void InitializationSequence::dump() const {
7136 dump(llvm::errs());
7137 }
7138
DiagnoseNarrowingInInitList(Sema & S,const ImplicitConversionSequence & ICS,QualType PreNarrowingType,QualType EntityType,const Expr * PostInit)7139 static void DiagnoseNarrowingInInitList(Sema &S,
7140 const ImplicitConversionSequence &ICS,
7141 QualType PreNarrowingType,
7142 QualType EntityType,
7143 const Expr *PostInit) {
7144 const StandardConversionSequence *SCS = nullptr;
7145 switch (ICS.getKind()) {
7146 case ImplicitConversionSequence::StandardConversion:
7147 SCS = &ICS.Standard;
7148 break;
7149 case ImplicitConversionSequence::UserDefinedConversion:
7150 SCS = &ICS.UserDefined.After;
7151 break;
7152 case ImplicitConversionSequence::AmbiguousConversion:
7153 case ImplicitConversionSequence::EllipsisConversion:
7154 case ImplicitConversionSequence::BadConversion:
7155 return;
7156 }
7157
7158 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
7159 APValue ConstantValue;
7160 QualType ConstantType;
7161 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7162 ConstantType)) {
7163 case NK_Not_Narrowing:
7164 // No narrowing occurred.
7165 return;
7166
7167 case NK_Type_Narrowing:
7168 // This was a floating-to-integer conversion, which is always considered a
7169 // narrowing conversion even if the value is a constant and can be
7170 // represented exactly as an integer.
7171 S.Diag(PostInit->getLocStart(),
7172 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7173 ? diag::warn_init_list_type_narrowing
7174 : diag::ext_init_list_type_narrowing)
7175 << PostInit->getSourceRange()
7176 << PreNarrowingType.getLocalUnqualifiedType()
7177 << EntityType.getLocalUnqualifiedType();
7178 break;
7179
7180 case NK_Constant_Narrowing:
7181 // A constant value was narrowed.
7182 S.Diag(PostInit->getLocStart(),
7183 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7184 ? diag::warn_init_list_constant_narrowing
7185 : diag::ext_init_list_constant_narrowing)
7186 << PostInit->getSourceRange()
7187 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
7188 << EntityType.getLocalUnqualifiedType();
7189 break;
7190
7191 case NK_Variable_Narrowing:
7192 // A variable's value may have been narrowed.
7193 S.Diag(PostInit->getLocStart(),
7194 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7195 ? diag::warn_init_list_variable_narrowing
7196 : diag::ext_init_list_variable_narrowing)
7197 << PostInit->getSourceRange()
7198 << PreNarrowingType.getLocalUnqualifiedType()
7199 << EntityType.getLocalUnqualifiedType();
7200 break;
7201 }
7202
7203 SmallString<128> StaticCast;
7204 llvm::raw_svector_ostream OS(StaticCast);
7205 OS << "static_cast<";
7206 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7207 // It's important to use the typedef's name if there is one so that the
7208 // fixit doesn't break code using types like int64_t.
7209 //
7210 // FIXME: This will break if the typedef requires qualification. But
7211 // getQualifiedNameAsString() includes non-machine-parsable components.
7212 OS << *TT->getDecl();
7213 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
7214 OS << BT->getName(S.getLangOpts());
7215 else {
7216 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7217 // with a broken cast.
7218 return;
7219 }
7220 OS << ">(";
7221 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
7222 << PostInit->getSourceRange()
7223 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7224 << FixItHint::CreateInsertion(
7225 S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
7226 }
7227
7228 //===----------------------------------------------------------------------===//
7229 // Initialization helper functions
7230 //===----------------------------------------------------------------------===//
7231 bool
CanPerformCopyInitialization(const InitializedEntity & Entity,ExprResult Init)7232 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7233 ExprResult Init) {
7234 if (Init.isInvalid())
7235 return false;
7236
7237 Expr *InitE = Init.get();
7238 assert(InitE && "No initialization expression");
7239
7240 InitializationKind Kind
7241 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
7242 InitializationSequence Seq(*this, Entity, Kind, InitE);
7243 return !Seq.Failed();
7244 }
7245
7246 ExprResult
PerformCopyInitialization(const InitializedEntity & Entity,SourceLocation EqualLoc,ExprResult Init,bool TopLevelOfInitList,bool AllowExplicit)7247 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7248 SourceLocation EqualLoc,
7249 ExprResult Init,
7250 bool TopLevelOfInitList,
7251 bool AllowExplicit) {
7252 if (Init.isInvalid())
7253 return ExprError();
7254
7255 Expr *InitE = Init.get();
7256 assert(InitE && "No initialization expression?");
7257
7258 if (EqualLoc.isInvalid())
7259 EqualLoc = InitE->getLocStart();
7260
7261 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
7262 EqualLoc,
7263 AllowExplicit);
7264 InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
7265 Init.get();
7266
7267 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);
7268
7269 return Result;
7270 }
7271