1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis for initializers.
12 //===----------------------------------------------------------------------===//
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"
29 using namespace clang;
31 //===----------------------------------------------------------------------===//
32 // Sema Initialization Checking
33 //===----------------------------------------------------------------------===//
35 /// \brief Check whether T is compatible with a wide character type (wchar_t,
36 /// char16_t or char32_t).
37 static bool IsWideCharCompatible(QualType T, ASTContext &Context) {
38 if (Context.typesAreCompatible(Context.getWideCharType(), T))
40 if (Context.getLangOpts().CPlusPlus || Context.getLangOpts().C11) {
41 return Context.typesAreCompatible(Context.Char16Ty, T) ||
42 Context.typesAreCompatible(Context.Char32Ty, T);
47 enum StringInitFailureKind {
49 SIF_NarrowStringIntoWideChar,
50 SIF_WideStringIntoChar,
51 SIF_IncompatWideStringIntoWideChar,
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.
59 static StringInitFailureKind IsStringInit(Expr *Init, const ArrayType *AT,
60 ASTContext &Context) {
61 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT))
64 // See if this is a string literal or @encode.
65 Init = Init->IgnoreParens();
67 // Handle @encode, which is a narrow string.
68 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType())
71 // Otherwise we can only handle string literals.
72 StringLiteral *SL = dyn_cast<StringLiteral>(Init);
76 const QualType ElemTy =
77 Context.getCanonicalType(AT->getElementType()).getUnqualifiedType();
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())
86 if (IsWideCharCompatible(ElemTy, Context))
87 return SIF_NarrowStringIntoWideChar;
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))
97 if (ElemTy->isCharType())
98 return SIF_WideStringIntoChar;
99 if (IsWideCharCompatible(ElemTy, Context))
100 return SIF_IncompatWideStringIntoWideChar;
102 case StringLiteral::UTF32:
103 if (Context.typesAreCompatible(Context.Char32Ty, ElemTy))
105 if (ElemTy->isCharType())
106 return SIF_WideStringIntoChar;
107 if (IsWideCharCompatible(ElemTy, Context))
108 return SIF_IncompatWideStringIntoWideChar;
110 case StringLiteral::Wide:
111 if (Context.typesAreCompatible(Context.getWideCharType(), ElemTy))
113 if (ElemTy->isCharType())
114 return SIF_WideStringIntoChar;
115 if (IsWideCharCompatible(ElemTy, Context))
116 return SIF_IncompatWideStringIntoWideChar;
120 llvm_unreachable("missed a StringLiteral kind?");
123 static StringInitFailureKind IsStringInit(Expr *init, QualType declType,
124 ASTContext &Context) {
125 const ArrayType *arrayType = Context.getAsArrayType(declType);
128 return IsStringInit(init, arrayType, Context);
131 /// Update the type of a string literal, including any surrounding parentheses,
132 /// to match the type of the object which it is initializing.
133 static void updateStringLiteralType(Expr *E, QualType Ty) {
136 if (isa<StringLiteral>(E) || isa<ObjCEncodeExpr>(E))
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();
145 llvm_unreachable("unexpected expr in string literal init");
149 static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT,
151 // Get the length of the string as parsed.
152 auto *ConstantArrayTy =
153 cast<ConstantArrayType>(Str->getType()->getAsArrayTypeUnsafe());
154 uint64_t StrLength = ConstantArrayTy->getSize().getZExtValue();
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(),
163 ArrayType::Normal, 0);
164 updateStringLiteralType(Str, DeclT);
168 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
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:
178 // unsigned char a[2] = "\pa";
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();
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();
196 // Set the type to the actual size that we are initializing. If we have
198 // char x[1] = "foo";
199 // then this will set the string literal's type to char[1].
200 updateStringLiteralType(Str, DeclT);
203 //===----------------------------------------------------------------------===//
204 // Semantic checking for initializer lists.
205 //===----------------------------------------------------------------------===//
207 /// @brief Semantic checking for initializer lists.
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.
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
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.
235 class InitListChecker {
238 bool VerifyOnly; // no diagnostics, no structure building
239 llvm::DenseMap<InitListExpr *, InitListExpr *> SyntacticToSemantic;
240 InitListExpr *FullyStructuredList;
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,
254 InitListExpr *StructuredList,
255 unsigned &StructuredIndex,
256 bool TopLevelObject = false);
257 void CheckSubElementType(const InitializedEntity &Entity,
258 InitListExpr *IList, QualType ElemType,
260 InitListExpr *StructuredList,
261 unsigned &StructuredIndex);
262 void CheckComplexType(const InitializedEntity &Entity,
263 InitListExpr *IList, QualType DeclType,
265 InitListExpr *StructuredList,
266 unsigned &StructuredIndex);
267 void CheckScalarType(const InitializedEntity &Entity,
268 InitListExpr *IList, QualType DeclType,
270 InitListExpr *StructuredList,
271 unsigned &StructuredIndex);
272 void CheckReferenceType(const InitializedEntity &Entity,
273 InitListExpr *IList, QualType DeclType,
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,
297 QualType &CurrentObjectType,
298 RecordDecl::field_iterator *NextField,
299 llvm::APSInt *NextElementIndex,
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 bool IsFullyOverwritten = false);
311 void UpdateStructuredListElement(InitListExpr *StructuredList,
312 unsigned &StructuredIndex,
314 int numArrayElements(QualType DeclType);
315 int numStructUnionElements(QualType DeclType);
317 static ExprResult PerformEmptyInit(Sema &SemaRef,
319 const InitializedEntity &Entity,
322 // Explanation on the "FillWithNoInit" mode:
324 // Assume we have the following definitions (Case#1):
325 // struct P { char x[6][6]; } xp = { .x[1] = "bar" };
326 // struct PP { struct P lp; } l = { .lp = xp, .lp.x[1][2] = 'f' };
328 // l.lp.x[1][0..1] should not be filled with implicit initializers because the
329 // "base" initializer "xp" will provide values for them; l.lp.x[1] will be "baf".
331 // But if we have (Case#2):
332 // struct PP l = { .lp = xp, .lp.x[1] = { [2] = 'f' } };
334 // l.lp.x[1][0..1] are implicitly initialized and do not use values from the
335 // "base" initializer; l.lp.x[1] will be "\0\0f\0\0\0".
337 // To distinguish Case#1 from Case#2, and also to avoid leaving many "holes"
338 // in the InitListExpr, the "holes" in Case#1 are filled not with empty
339 // initializers but with special "NoInitExpr" place holders, which tells the
340 // CodeGen not to generate any initializers for these parts.
341 void FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
342 const InitializedEntity &ParentEntity,
343 InitListExpr *ILE, bool &RequiresSecondPass,
344 bool FillWithNoInit = false);
345 void FillInEmptyInitializations(const InitializedEntity &Entity,
346 InitListExpr *ILE, bool &RequiresSecondPass,
347 bool FillWithNoInit = false);
348 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
349 Expr *InitExpr, FieldDecl *Field,
350 bool TopLevelObject);
351 void CheckEmptyInitializable(const InitializedEntity &Entity,
355 InitListChecker(Sema &S, const InitializedEntity &Entity,
356 InitListExpr *IL, QualType &T, bool VerifyOnly);
357 bool HadError() { return hadError; }
359 // @brief Retrieves the fully-structured initializer list used for
360 // semantic analysis and code generation.
361 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
363 } // end anonymous namespace
365 ExprResult InitListChecker::PerformEmptyInit(Sema &SemaRef,
367 const InitializedEntity &Entity,
369 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
371 MultiExprArg SubInit;
373 InitListExpr DummyInitList(SemaRef.Context, Loc, None, Loc);
375 // C++ [dcl.init.aggr]p7:
376 // If there are fewer initializer-clauses in the list than there are
377 // members in the aggregate, then each member not explicitly initialized
379 bool EmptyInitList = SemaRef.getLangOpts().CPlusPlus11 &&
380 Entity.getType()->getBaseElementTypeUnsafe()->isRecordType();
383 // shall be initialized [...] from an empty initializer list.
385 // We apply the resolution of this DR to C++11 but not C++98, since C++98
386 // does not have useful semantics for initialization from an init list.
387 // We treat this as copy-initialization, because aggregate initialization
388 // always performs copy-initialization on its elements.
390 // Only do this if we're initializing a class type, to avoid filling in
391 // the initializer list where possible.
392 InitExpr = VerifyOnly ? &DummyInitList : new (SemaRef.Context)
393 InitListExpr(SemaRef.Context, Loc, None, Loc);
394 InitExpr->setType(SemaRef.Context.VoidTy);
396 Kind = InitializationKind::CreateCopy(Loc, Loc);
399 // shall be value-initialized.
402 InitializationSequence InitSeq(SemaRef, Entity, Kind, SubInit);
403 // libstdc++4.6 marks the vector default constructor as explicit in
404 // _GLIBCXX_DEBUG mode, so recover using the C++03 logic in that case.
405 // stlport does so too. Look for std::__debug for libstdc++, and for
406 // std:: for stlport. This is effectively a compiler-side implementation of
408 if (!InitSeq && EmptyInitList && InitSeq.getFailureKind() ==
409 InitializationSequence::FK_ExplicitConstructor) {
410 OverloadCandidateSet::iterator Best;
411 OverloadingResult O =
412 InitSeq.getFailedCandidateSet()
413 .BestViableFunction(SemaRef, Kind.getLocation(), Best);
415 assert(O == OR_Success && "Inconsistent overload resolution");
416 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
417 CXXRecordDecl *R = CtorDecl->getParent();
419 if (CtorDecl->getMinRequiredArguments() == 0 &&
420 CtorDecl->isExplicit() && R->getDeclName() &&
421 SemaRef.SourceMgr.isInSystemHeader(CtorDecl->getLocation())) {
424 bool IsInStd = false;
425 for (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(R->getDeclContext());
426 ND && !IsInStd; ND = dyn_cast<NamespaceDecl>(ND->getParent())) {
427 if (SemaRef.getStdNamespace()->InEnclosingNamespaceSetOf(ND))
431 if (IsInStd && llvm::StringSwitch<bool>(R->getName())
432 .Cases("basic_string", "deque", "forward_list", true)
433 .Cases("list", "map", "multimap", "multiset", true)
434 .Cases("priority_queue", "queue", "set", "stack", true)
435 .Cases("unordered_map", "unordered_set", "vector", true)
437 InitSeq.InitializeFrom(
439 InitializationKind::CreateValue(Loc, Loc, Loc, true),
440 MultiExprArg(), /*TopLevelOfInitList=*/false);
441 // Emit a warning for this. System header warnings aren't shown
442 // by default, but people working on system headers should see it.
444 SemaRef.Diag(CtorDecl->getLocation(),
445 diag::warn_invalid_initializer_from_system_header);
446 SemaRef.Diag(Entity.getDecl()->getLocation(),
447 diag::note_used_in_initialization_here);
454 InitSeq.Diagnose(SemaRef, Entity, Kind, SubInit);
455 if (Entity.getKind() == InitializedEntity::EK_Member)
456 SemaRef.Diag(Entity.getDecl()->getLocation(),
457 diag::note_in_omitted_aggregate_initializer)
458 << /*field*/1 << Entity.getDecl();
459 else if (Entity.getKind() == InitializedEntity::EK_ArrayElement)
460 SemaRef.Diag(Loc, diag::note_in_omitted_aggregate_initializer)
461 << /*array element*/0 << Entity.getElementIndex();
466 return VerifyOnly ? ExprResult(static_cast<Expr *>(nullptr))
467 : InitSeq.Perform(SemaRef, Entity, Kind, SubInit);
470 void InitListChecker::CheckEmptyInitializable(const InitializedEntity &Entity,
471 SourceLocation Loc) {
473 "CheckEmptyInitializable is only inteded for verification mode.");
474 if (PerformEmptyInit(SemaRef, Loc, Entity, /*VerifyOnly*/true).isInvalid())
478 void InitListChecker::FillInEmptyInitForField(unsigned Init, FieldDecl *Field,
479 const InitializedEntity &ParentEntity,
481 bool &RequiresSecondPass,
482 bool FillWithNoInit) {
483 SourceLocation Loc = ILE->getLocEnd();
484 unsigned NumInits = ILE->getNumInits();
485 InitializedEntity MemberEntity
486 = InitializedEntity::InitializeMember(Field, &ParentEntity);
488 if (const RecordType *RType = ILE->getType()->getAs<RecordType>())
489 if (!RType->getDecl()->isUnion())
490 assert(Init < NumInits && "This ILE should have been expanded");
492 if (Init >= NumInits || !ILE->getInit(Init)) {
493 if (FillWithNoInit) {
494 Expr *Filler = new (SemaRef.Context) NoInitExpr(Field->getType());
496 ILE->setInit(Init, Filler);
498 ILE->updateInit(SemaRef.Context, Init, Filler);
501 // C++1y [dcl.init.aggr]p7:
502 // If there are fewer initializer-clauses in the list than there are
503 // members in the aggregate, then each member not explicitly initialized
504 // shall be initialized from its brace-or-equal-initializer [...]
505 if (Field->hasInClassInitializer()) {
506 ExprResult DIE = SemaRef.BuildCXXDefaultInitExpr(Loc, Field);
507 if (DIE.isInvalid()) {
512 ILE->setInit(Init, DIE.get());
514 ILE->updateInit(SemaRef.Context, Init, DIE.get());
515 RequiresSecondPass = true;
520 if (Field->getType()->isReferenceType()) {
521 // C++ [dcl.init.aggr]p9:
522 // If an incomplete or empty initializer-list leaves a
523 // member of reference type uninitialized, the program is
525 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
527 << ILE->getSyntacticForm()->getSourceRange();
528 SemaRef.Diag(Field->getLocation(),
529 diag::note_uninit_reference_member);
534 ExprResult MemberInit = PerformEmptyInit(SemaRef, Loc, MemberEntity,
535 /*VerifyOnly*/false);
536 if (MemberInit.isInvalid()) {
543 } else if (Init < NumInits) {
544 ILE->setInit(Init, MemberInit.getAs<Expr>());
545 } else if (!isa<ImplicitValueInitExpr>(MemberInit.get())) {
546 // Empty initialization requires a constructor call, so
547 // extend the initializer list to include the constructor
548 // call and make a note that we'll need to take another pass
549 // through the initializer list.
550 ILE->updateInit(SemaRef.Context, Init, MemberInit.getAs<Expr>());
551 RequiresSecondPass = true;
553 } else if (InitListExpr *InnerILE
554 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
555 FillInEmptyInitializations(MemberEntity, InnerILE,
556 RequiresSecondPass, FillWithNoInit);
557 else if (DesignatedInitUpdateExpr *InnerDIUE
558 = dyn_cast<DesignatedInitUpdateExpr>(ILE->getInit(Init)))
559 FillInEmptyInitializations(MemberEntity, InnerDIUE->getUpdater(),
560 RequiresSecondPass, /*FillWithNoInit =*/ true);
563 /// Recursively replaces NULL values within the given initializer list
564 /// with expressions that perform value-initialization of the
565 /// appropriate type.
567 InitListChecker::FillInEmptyInitializations(const InitializedEntity &Entity,
569 bool &RequiresSecondPass,
570 bool FillWithNoInit) {
571 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
572 "Should not have void type");
574 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
575 const RecordDecl *RDecl = RType->getDecl();
576 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
577 FillInEmptyInitForField(0, ILE->getInitializedFieldInUnion(),
578 Entity, ILE, RequiresSecondPass, FillWithNoInit);
579 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
580 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
581 for (auto *Field : RDecl->fields()) {
582 if (Field->hasInClassInitializer()) {
583 FillInEmptyInitForField(0, Field, Entity, ILE, RequiresSecondPass,
589 // The fields beyond ILE->getNumInits() are default initialized, so in
590 // order to leave them uninitialized, the ILE is expanded and the extra
591 // fields are then filled with NoInitExpr.
592 unsigned NumFields = 0;
593 for (auto *Field : RDecl->fields())
594 if (!Field->isUnnamedBitfield())
596 if (ILE->getNumInits() < NumFields)
597 ILE->resizeInits(SemaRef.Context, NumFields);
600 for (auto *Field : RDecl->fields()) {
601 if (Field->isUnnamedBitfield())
607 FillInEmptyInitForField(Init, Field, Entity, ILE, RequiresSecondPass,
614 // Only look at the first initialization of a union.
615 if (RDecl->isUnion())
623 QualType ElementType;
625 InitializedEntity ElementEntity = Entity;
626 unsigned NumInits = ILE->getNumInits();
627 unsigned NumElements = NumInits;
628 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
629 ElementType = AType->getElementType();
630 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
631 NumElements = CAType->getSize().getZExtValue();
632 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
634 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
635 ElementType = VType->getElementType();
636 NumElements = VType->getNumElements();
637 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
640 ElementType = ILE->getType();
642 for (unsigned Init = 0; Init != NumElements; ++Init) {
646 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
647 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
648 ElementEntity.setElementIndex(Init);
650 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : nullptr);
651 if (!InitExpr && Init < NumInits && ILE->hasArrayFiller())
652 ILE->setInit(Init, ILE->getArrayFiller());
653 else if (!InitExpr && !ILE->hasArrayFiller()) {
654 Expr *Filler = nullptr;
657 Filler = new (SemaRef.Context) NoInitExpr(ElementType);
659 ExprResult ElementInit = PerformEmptyInit(SemaRef, ILE->getLocEnd(),
661 /*VerifyOnly*/false);
662 if (ElementInit.isInvalid()) {
667 Filler = ElementInit.getAs<Expr>();
672 } else if (Init < NumInits) {
673 // For arrays, just set the expression used for value-initialization
674 // of the "holes" in the array.
675 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
676 ILE->setArrayFiller(Filler);
678 ILE->setInit(Init, Filler);
680 // For arrays, just set the expression used for value-initialization
681 // of the rest of elements and exit.
682 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
683 ILE->setArrayFiller(Filler);
687 if (!isa<ImplicitValueInitExpr>(Filler) && !isa<NoInitExpr>(Filler)) {
688 // Empty initialization requires a constructor call, so
689 // extend the initializer list to include the constructor
690 // call and make a note that we'll need to take another pass
691 // through the initializer list.
692 ILE->updateInit(SemaRef.Context, Init, Filler);
693 RequiresSecondPass = true;
696 } else if (InitListExpr *InnerILE
697 = dyn_cast_or_null<InitListExpr>(InitExpr))
698 FillInEmptyInitializations(ElementEntity, InnerILE, RequiresSecondPass,
700 else if (DesignatedInitUpdateExpr *InnerDIUE
701 = dyn_cast_or_null<DesignatedInitUpdateExpr>(InitExpr))
702 FillInEmptyInitializations(ElementEntity, InnerDIUE->getUpdater(),
703 RequiresSecondPass, /*FillWithNoInit =*/ true);
708 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
709 InitListExpr *IL, QualType &T,
711 : SemaRef(S), VerifyOnly(VerifyOnly) {
712 // FIXME: Check that IL isn't already the semantic form of some other
713 // InitListExpr. If it is, we'd create a broken AST.
717 FullyStructuredList =
718 getStructuredSubobjectInit(IL, 0, T, nullptr, 0, IL->getSourceRange());
719 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
720 /*TopLevelObject=*/true);
722 if (!hadError && !VerifyOnly) {
723 bool RequiresSecondPass = false;
724 FillInEmptyInitializations(Entity, FullyStructuredList, RequiresSecondPass);
725 if (RequiresSecondPass && !hadError)
726 FillInEmptyInitializations(Entity, FullyStructuredList,
731 int InitListChecker::numArrayElements(QualType DeclType) {
732 // FIXME: use a proper constant
733 int maxElements = 0x7FFFFFFF;
734 if (const ConstantArrayType *CAT =
735 SemaRef.Context.getAsConstantArrayType(DeclType)) {
736 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
741 int InitListChecker::numStructUnionElements(QualType DeclType) {
742 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
743 int InitializableMembers = 0;
744 for (const auto *Field : structDecl->fields())
745 if (!Field->isUnnamedBitfield())
746 ++InitializableMembers;
748 if (structDecl->isUnion())
749 return std::min(InitializableMembers, 1);
750 return InitializableMembers - structDecl->hasFlexibleArrayMember();
753 /// Check whether the range of the initializer \p ParentIList from element
754 /// \p Index onwards can be used to initialize an object of type \p T. Update
755 /// \p Index to indicate how many elements of the list were consumed.
757 /// This also fills in \p StructuredList, from element \p StructuredIndex
758 /// onwards, with the fully-braced, desugared form of the initialization.
759 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
760 InitListExpr *ParentIList,
761 QualType T, unsigned &Index,
762 InitListExpr *StructuredList,
763 unsigned &StructuredIndex) {
766 if (T->isArrayType())
767 maxElements = numArrayElements(T);
768 else if (T->isRecordType())
769 maxElements = numStructUnionElements(T);
770 else if (T->isVectorType())
771 maxElements = T->getAs<VectorType>()->getNumElements();
773 llvm_unreachable("CheckImplicitInitList(): Illegal type");
775 if (maxElements == 0) {
777 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
778 diag::err_implicit_empty_initializer);
784 // Build a structured initializer list corresponding to this subobject.
785 InitListExpr *StructuredSubobjectInitList
786 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
788 SourceRange(ParentIList->getInit(Index)->getLocStart(),
789 ParentIList->getSourceRange().getEnd()));
790 unsigned StructuredSubobjectInitIndex = 0;
792 // Check the element types and build the structural subobject.
793 unsigned StartIndex = Index;
794 CheckListElementTypes(Entity, ParentIList, T,
795 /*SubobjectIsDesignatorContext=*/false, Index,
796 StructuredSubobjectInitList,
797 StructuredSubobjectInitIndex);
800 StructuredSubobjectInitList->setType(T);
802 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
803 // Update the structured sub-object initializer so that it's ending
804 // range corresponds with the end of the last initializer it used.
805 if (EndIndex < ParentIList->getNumInits()) {
806 SourceLocation EndLoc
807 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
808 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
811 // Complain about missing braces.
812 if (T->isArrayType() || T->isRecordType()) {
813 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
814 diag::warn_missing_braces)
815 << StructuredSubobjectInitList->getSourceRange()
816 << FixItHint::CreateInsertion(
817 StructuredSubobjectInitList->getLocStart(), "{")
818 << FixItHint::CreateInsertion(
819 SemaRef.getLocForEndOfToken(
820 StructuredSubobjectInitList->getLocEnd()),
826 /// Warn that \p Entity was of scalar type and was initialized by a
827 /// single-element braced initializer list.
828 static void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity,
829 SourceRange Braces) {
830 // Don't warn during template instantiation. If the initialization was
831 // non-dependent, we warned during the initial parse; otherwise, the
832 // type might not be scalar in some uses of the template.
833 if (!S.ActiveTemplateInstantiations.empty())
838 switch (Entity.getKind()) {
839 case InitializedEntity::EK_VectorElement:
840 case InitializedEntity::EK_ComplexElement:
841 case InitializedEntity::EK_ArrayElement:
842 case InitializedEntity::EK_Parameter:
843 case InitializedEntity::EK_Parameter_CF_Audited:
844 case InitializedEntity::EK_Result:
845 // Extra braces here are suspicious.
846 DiagID = diag::warn_braces_around_scalar_init;
849 case InitializedEntity::EK_Member:
850 // Warn on aggregate initialization but not on ctor init list or
851 // default member initializer.
852 if (Entity.getParent())
853 DiagID = diag::warn_braces_around_scalar_init;
856 case InitializedEntity::EK_Variable:
857 case InitializedEntity::EK_LambdaCapture:
858 // No warning, might be direct-list-initialization.
859 // FIXME: Should we warn for copy-list-initialization in these cases?
862 case InitializedEntity::EK_New:
863 case InitializedEntity::EK_Temporary:
864 case InitializedEntity::EK_CompoundLiteralInit:
865 // No warning, braces are part of the syntax of the underlying construct.
868 case InitializedEntity::EK_RelatedResult:
869 // No warning, we already warned when initializing the result.
872 case InitializedEntity::EK_Exception:
873 case InitializedEntity::EK_Base:
874 case InitializedEntity::EK_Delegating:
875 case InitializedEntity::EK_BlockElement:
876 llvm_unreachable("unexpected braced scalar init");
880 S.Diag(Braces.getBegin(), DiagID)
882 << FixItHint::CreateRemoval(Braces.getBegin())
883 << FixItHint::CreateRemoval(Braces.getEnd());
888 /// Check whether the initializer \p IList (that was written with explicit
889 /// braces) can be used to initialize an object of type \p T.
891 /// This also fills in \p StructuredList with the fully-braced, desugared
892 /// form of the initialization.
893 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
894 InitListExpr *IList, QualType &T,
895 InitListExpr *StructuredList,
896 bool TopLevelObject) {
898 SyntacticToSemantic[IList] = StructuredList;
899 StructuredList->setSyntacticForm(IList);
902 unsigned Index = 0, StructuredIndex = 0;
903 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
904 Index, StructuredList, StructuredIndex, TopLevelObject);
907 if (!ExprTy->isArrayType())
908 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
909 IList->setType(ExprTy);
910 StructuredList->setType(ExprTy);
915 if (Index < IList->getNumInits()) {
916 // We have leftover initializers
918 if (SemaRef.getLangOpts().CPlusPlus ||
919 (SemaRef.getLangOpts().OpenCL &&
920 IList->getType()->isVectorType())) {
926 if (StructuredIndex == 1 &&
927 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
929 unsigned DK = diag::ext_excess_initializers_in_char_array_initializer;
930 if (SemaRef.getLangOpts().CPlusPlus) {
931 DK = diag::err_excess_initializers_in_char_array_initializer;
935 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
936 << IList->getInit(Index)->getSourceRange();
937 } else if (!T->isIncompleteType()) {
938 // Don't complain for incomplete types, since we'll get an error
940 QualType CurrentObjectType = StructuredList->getType();
942 CurrentObjectType->isArrayType()? 0 :
943 CurrentObjectType->isVectorType()? 1 :
944 CurrentObjectType->isScalarType()? 2 :
945 CurrentObjectType->isUnionType()? 3 :
948 unsigned DK = diag::ext_excess_initializers;
949 if (SemaRef.getLangOpts().CPlusPlus) {
950 DK = diag::err_excess_initializers;
953 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
954 DK = diag::err_excess_initializers;
958 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
959 << initKind << IList->getInit(Index)->getSourceRange();
963 if (!VerifyOnly && T->isScalarType() &&
964 IList->getNumInits() == 1 && !isa<InitListExpr>(IList->getInit(0)))
965 warnBracedScalarInit(SemaRef, Entity, IList->getSourceRange());
968 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
971 bool SubobjectIsDesignatorContext,
973 InitListExpr *StructuredList,
974 unsigned &StructuredIndex,
975 bool TopLevelObject) {
976 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
977 // Explicitly braced initializer for complex type can be real+imaginary
979 CheckComplexType(Entity, IList, DeclType, Index,
980 StructuredList, StructuredIndex);
981 } else if (DeclType->isScalarType()) {
982 CheckScalarType(Entity, IList, DeclType, Index,
983 StructuredList, StructuredIndex);
984 } else if (DeclType->isVectorType()) {
985 CheckVectorType(Entity, IList, DeclType, Index,
986 StructuredList, StructuredIndex);
987 } else if (DeclType->isRecordType()) {
988 assert(DeclType->isAggregateType() &&
989 "non-aggregate records should be handed in CheckSubElementType");
990 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
991 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
992 SubobjectIsDesignatorContext, Index,
993 StructuredList, StructuredIndex,
995 } else if (DeclType->isArrayType()) {
997 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
999 CheckArrayType(Entity, IList, DeclType, Zero,
1000 SubobjectIsDesignatorContext, Index,
1001 StructuredList, StructuredIndex);
1002 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
1003 // This type is invalid, issue a diagnostic.
1006 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1009 } else if (DeclType->isReferenceType()) {
1010 CheckReferenceType(Entity, IList, DeclType, Index,
1011 StructuredList, StructuredIndex);
1012 } else if (DeclType->isObjCObjectType()) {
1014 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
1019 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
1025 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
1026 InitListExpr *IList,
1029 InitListExpr *StructuredList,
1030 unsigned &StructuredIndex) {
1031 Expr *expr = IList->getInit(Index);
1033 if (ElemType->isReferenceType())
1034 return CheckReferenceType(Entity, IList, ElemType, Index,
1035 StructuredList, StructuredIndex);
1037 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
1038 if (SubInitList->getNumInits() == 1 &&
1039 IsStringInit(SubInitList->getInit(0), ElemType, SemaRef.Context) ==
1041 expr = SubInitList->getInit(0);
1042 } else if (!SemaRef.getLangOpts().CPlusPlus) {
1043 InitListExpr *InnerStructuredList
1044 = getStructuredSubobjectInit(IList, Index, ElemType,
1045 StructuredList, StructuredIndex,
1046 SubInitList->getSourceRange(), true);
1047 CheckExplicitInitList(Entity, SubInitList, ElemType,
1048 InnerStructuredList);
1050 if (!hadError && !VerifyOnly) {
1051 bool RequiresSecondPass = false;
1052 FillInEmptyInitializations(Entity, InnerStructuredList,
1053 RequiresSecondPass);
1054 if (RequiresSecondPass && !hadError)
1055 FillInEmptyInitializations(Entity, InnerStructuredList,
1056 RequiresSecondPass);
1062 // C++ initialization is handled later.
1063 } else if (isa<ImplicitValueInitExpr>(expr)) {
1064 // This happens during template instantiation when we see an InitListExpr
1065 // that we've already checked once.
1066 assert(SemaRef.Context.hasSameType(expr->getType(), ElemType) &&
1067 "found implicit initialization for the wrong type");
1069 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1074 if (SemaRef.getLangOpts().CPlusPlus) {
1075 // C++ [dcl.init.aggr]p2:
1076 // Each member is copy-initialized from the corresponding
1077 // initializer-clause.
1079 // FIXME: Better EqualLoc?
1080 InitializationKind Kind =
1081 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
1082 InitializationSequence Seq(SemaRef, Entity, Kind, expr,
1083 /*TopLevelOfInitList*/ true);
1085 // C++14 [dcl.init.aggr]p13:
1086 // If the assignment-expression can initialize a member, the member is
1087 // initialized. Otherwise [...] brace elision is assumed
1089 // Brace elision is never performed if the element is not an
1090 // assignment-expression.
1091 if (Seq || isa<InitListExpr>(expr)) {
1094 Seq.Perform(SemaRef, Entity, Kind, expr);
1095 if (Result.isInvalid())
1098 UpdateStructuredListElement(StructuredList, StructuredIndex,
1099 Result.getAs<Expr>());
1106 // Fall through for subaggregate initialization
1107 } else if (ElemType->isScalarType() || ElemType->isAtomicType()) {
1108 // FIXME: Need to handle atomic aggregate types with implicit init lists.
1109 return CheckScalarType(Entity, IList, ElemType, Index,
1110 StructuredList, StructuredIndex);
1111 } else if (const ArrayType *arrayType =
1112 SemaRef.Context.getAsArrayType(ElemType)) {
1113 // arrayType can be incomplete if we're initializing a flexible
1114 // array member. There's nothing we can do with the completed
1115 // type here, though.
1117 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
1119 CheckStringInit(expr, ElemType, arrayType, SemaRef);
1120 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1126 // Fall through for subaggregate initialization.
1129 assert((ElemType->isRecordType() || ElemType->isVectorType()) &&
1134 // The initializer for a structure or union object that has
1135 // automatic storage duration shall be either an initializer
1136 // list as described below, or a single expression that has
1137 // compatible structure or union type. In the latter case, the
1138 // initial value of the object, including unnamed members, is
1139 // that of the expression.
1140 ExprResult ExprRes = expr;
1141 if (SemaRef.CheckSingleAssignmentConstraints(
1142 ElemType, ExprRes, !VerifyOnly) != Sema::Incompatible) {
1143 if (ExprRes.isInvalid())
1146 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.get());
1147 if (ExprRes.isInvalid())
1150 UpdateStructuredListElement(StructuredList, StructuredIndex,
1151 ExprRes.getAs<Expr>());
1156 // Fall through for subaggregate initialization
1159 // C++ [dcl.init.aggr]p12:
1161 // [...] Otherwise, if the member is itself a non-empty
1162 // subaggregate, brace elision is assumed and the initializer is
1163 // considered for the initialization of the first member of
1164 // the subaggregate.
1165 if (!SemaRef.getLangOpts().OpenCL &&
1166 (ElemType->isAggregateType() || ElemType->isVectorType())) {
1167 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
1172 // We cannot initialize this element, so let
1173 // PerformCopyInitialization produce the appropriate diagnostic.
1174 SemaRef.PerformCopyInitialization(Entity, SourceLocation(), expr,
1175 /*TopLevelOfInitList=*/true);
1183 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
1184 InitListExpr *IList, QualType DeclType,
1186 InitListExpr *StructuredList,
1187 unsigned &StructuredIndex) {
1188 assert(Index == 0 && "Index in explicit init list must be zero");
1190 // As an extension, clang supports complex initializers, which initialize
1191 // a complex number component-wise. When an explicit initializer list for
1192 // a complex number contains two two initializers, this extension kicks in:
1193 // it exepcts the initializer list to contain two elements convertible to
1194 // the element type of the complex type. The first element initializes
1195 // the real part, and the second element intitializes the imaginary part.
1197 if (IList->getNumInits() != 2)
1198 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
1201 // This is an extension in C. (The builtin _Complex type does not exist
1202 // in the C++ standard.)
1203 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
1204 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
1205 << IList->getSourceRange();
1207 // Initialize the complex number.
1208 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
1209 InitializedEntity ElementEntity =
1210 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1212 for (unsigned i = 0; i < 2; ++i) {
1213 ElementEntity.setElementIndex(Index);
1214 CheckSubElementType(ElementEntity, IList, elementType, Index,
1215 StructuredList, StructuredIndex);
1220 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
1221 InitListExpr *IList, QualType DeclType,
1223 InitListExpr *StructuredList,
1224 unsigned &StructuredIndex) {
1225 if (Index >= IList->getNumInits()) {
1227 SemaRef.Diag(IList->getLocStart(),
1228 SemaRef.getLangOpts().CPlusPlus11 ?
1229 diag::warn_cxx98_compat_empty_scalar_initializer :
1230 diag::err_empty_scalar_initializer)
1231 << IList->getSourceRange();
1232 hadError = !SemaRef.getLangOpts().CPlusPlus11;
1238 Expr *expr = IList->getInit(Index);
1239 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1240 // FIXME: This is invalid, and accepting it causes overload resolution
1241 // to pick the wrong overload in some corner cases.
1243 SemaRef.Diag(SubIList->getLocStart(),
1244 diag::ext_many_braces_around_scalar_init)
1245 << SubIList->getSourceRange();
1247 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1250 } else if (isa<DesignatedInitExpr>(expr)) {
1252 SemaRef.Diag(expr->getLocStart(),
1253 diag::err_designator_for_scalar_init)
1254 << DeclType << expr->getSourceRange();
1262 if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1269 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1270 /*TopLevelOfInitList=*/true);
1272 Expr *ResultExpr = nullptr;
1274 if (Result.isInvalid())
1275 hadError = true; // types weren't compatible.
1277 ResultExpr = Result.getAs<Expr>();
1279 if (ResultExpr != expr) {
1280 // The type was promoted, update initializer list.
1281 IList->setInit(Index, ResultExpr);
1287 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1291 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1292 InitListExpr *IList, QualType DeclType,
1294 InitListExpr *StructuredList,
1295 unsigned &StructuredIndex) {
1296 if (Index >= IList->getNumInits()) {
1297 // FIXME: It would be wonderful if we could point at the actual member. In
1298 // general, it would be useful to pass location information down the stack,
1299 // so that we know the location (or decl) of the "current object" being
1302 SemaRef.Diag(IList->getLocStart(),
1303 diag::err_init_reference_member_uninitialized)
1305 << IList->getSourceRange();
1312 Expr *expr = IList->getInit(Index);
1313 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1315 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1316 << DeclType << IList->getSourceRange();
1324 if (!SemaRef.CanPerformCopyInitialization(Entity,expr))
1331 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), expr,
1332 /*TopLevelOfInitList=*/true);
1334 if (Result.isInvalid())
1337 expr = Result.getAs<Expr>();
1338 IList->setInit(Index, expr);
1343 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1347 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1348 InitListExpr *IList, QualType DeclType,
1350 InitListExpr *StructuredList,
1351 unsigned &StructuredIndex) {
1352 const VectorType *VT = DeclType->getAs<VectorType>();
1353 unsigned maxElements = VT->getNumElements();
1354 unsigned numEltsInit = 0;
1355 QualType elementType = VT->getElementType();
1357 if (Index >= IList->getNumInits()) {
1358 // Make sure the element type can be value-initialized.
1360 CheckEmptyInitializable(
1361 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity),
1362 IList->getLocEnd());
1366 if (!SemaRef.getLangOpts().OpenCL) {
1367 // If the initializing element is a vector, try to copy-initialize
1368 // instead of breaking it apart (which is doomed to failure anyway).
1369 Expr *Init = IList->getInit(Index);
1370 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1372 if (!SemaRef.CanPerformCopyInitialization(Entity, Init))
1379 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), Init,
1380 /*TopLevelOfInitList=*/true);
1382 Expr *ResultExpr = nullptr;
1383 if (Result.isInvalid())
1384 hadError = true; // types weren't compatible.
1386 ResultExpr = Result.getAs<Expr>();
1388 if (ResultExpr != Init) {
1389 // The type was promoted, update initializer list.
1390 IList->setInit(Index, ResultExpr);
1396 UpdateStructuredListElement(StructuredList, StructuredIndex,
1402 InitializedEntity ElementEntity =
1403 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1405 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1406 // Don't attempt to go past the end of the init list
1407 if (Index >= IList->getNumInits()) {
1409 CheckEmptyInitializable(ElementEntity, IList->getLocEnd());
1413 ElementEntity.setElementIndex(Index);
1414 CheckSubElementType(ElementEntity, IList, elementType, Index,
1415 StructuredList, StructuredIndex);
1421 bool isBigEndian = SemaRef.Context.getTargetInfo().isBigEndian();
1422 const VectorType *T = Entity.getType()->getAs<VectorType>();
1423 if (isBigEndian && (T->getVectorKind() == VectorType::NeonVector ||
1424 T->getVectorKind() == VectorType::NeonPolyVector)) {
1425 // The ability to use vector initializer lists is a GNU vector extension
1426 // and is unrelated to the NEON intrinsics in arm_neon.h. On little
1427 // endian machines it works fine, however on big endian machines it
1428 // exhibits surprising behaviour:
1430 // uint32x2_t x = {42, 64};
1431 // return vget_lane_u32(x, 0); // Will return 64.
1433 // Because of this, explicitly call out that it is non-portable.
1435 SemaRef.Diag(IList->getLocStart(),
1436 diag::warn_neon_vector_initializer_non_portable);
1438 const char *typeCode;
1439 unsigned typeSize = SemaRef.Context.getTypeSize(elementType);
1441 if (elementType->isFloatingType())
1443 else if (elementType->isSignedIntegerType())
1445 else if (elementType->isUnsignedIntegerType())
1448 llvm_unreachable("Invalid element type!");
1450 SemaRef.Diag(IList->getLocStart(),
1451 SemaRef.Context.getTypeSize(VT) > 64 ?
1452 diag::note_neon_vector_initializer_non_portable_q :
1453 diag::note_neon_vector_initializer_non_portable)
1454 << typeCode << typeSize;
1460 InitializedEntity ElementEntity =
1461 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1463 // OpenCL initializers allows vectors to be constructed from vectors.
1464 for (unsigned i = 0; i < maxElements; ++i) {
1465 // Don't attempt to go past the end of the init list
1466 if (Index >= IList->getNumInits())
1469 ElementEntity.setElementIndex(Index);
1471 QualType IType = IList->getInit(Index)->getType();
1472 if (!IType->isVectorType()) {
1473 CheckSubElementType(ElementEntity, IList, elementType, Index,
1474 StructuredList, StructuredIndex);
1478 const VectorType *IVT = IType->getAs<VectorType>();
1479 unsigned numIElts = IVT->getNumElements();
1481 if (IType->isExtVectorType())
1482 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1484 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1485 IVT->getVectorKind());
1486 CheckSubElementType(ElementEntity, IList, VecType, Index,
1487 StructuredList, StructuredIndex);
1488 numEltsInit += numIElts;
1492 // OpenCL requires all elements to be initialized.
1493 if (numEltsInit != maxElements) {
1495 SemaRef.Diag(IList->getLocStart(),
1496 diag::err_vector_incorrect_num_initializers)
1497 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1502 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1503 InitListExpr *IList, QualType &DeclType,
1504 llvm::APSInt elementIndex,
1505 bool SubobjectIsDesignatorContext,
1507 InitListExpr *StructuredList,
1508 unsigned &StructuredIndex) {
1509 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1511 // Check for the special-case of initializing an array with a string.
1512 if (Index < IList->getNumInits()) {
1513 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1515 // We place the string literal directly into the resulting
1516 // initializer list. This is the only place where the structure
1517 // of the structured initializer list doesn't match exactly,
1518 // because doing so would involve allocating one character
1519 // constant for each string.
1521 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1522 UpdateStructuredListElement(StructuredList, StructuredIndex,
1523 IList->getInit(Index));
1524 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1530 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1531 // Check for VLAs; in standard C it would be possible to check this
1532 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1533 // them in all sorts of strange places).
1535 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1536 diag::err_variable_object_no_init)
1537 << VAT->getSizeExpr()->getSourceRange();
1544 // We might know the maximum number of elements in advance.
1545 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1546 elementIndex.isUnsigned());
1547 bool maxElementsKnown = false;
1548 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1549 maxElements = CAT->getSize();
1550 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1551 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1552 maxElementsKnown = true;
1555 QualType elementType = arrayType->getElementType();
1556 while (Index < IList->getNumInits()) {
1557 Expr *Init = IList->getInit(Index);
1558 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1559 // If we're not the subobject that matches up with the '{' for
1560 // the designator, we shouldn't be handling the
1561 // designator. Return immediately.
1562 if (!SubobjectIsDesignatorContext)
1565 // Handle this designated initializer. elementIndex will be
1566 // updated to be the next array element we'll initialize.
1567 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1568 DeclType, nullptr, &elementIndex, Index,
1569 StructuredList, StructuredIndex, true,
1575 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1576 maxElements = maxElements.extend(elementIndex.getBitWidth());
1577 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1578 elementIndex = elementIndex.extend(maxElements.getBitWidth());
1579 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1581 // If the array is of incomplete type, keep track of the number of
1582 // elements in the initializer.
1583 if (!maxElementsKnown && elementIndex > maxElements)
1584 maxElements = elementIndex;
1589 // If we know the maximum number of elements, and we've already
1590 // hit it, stop consuming elements in the initializer list.
1591 if (maxElementsKnown && elementIndex == maxElements)
1594 InitializedEntity ElementEntity =
1595 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1597 // Check this element.
1598 CheckSubElementType(ElementEntity, IList, elementType, Index,
1599 StructuredList, StructuredIndex);
1602 // If the array is of incomplete type, keep track of the number of
1603 // elements in the initializer.
1604 if (!maxElementsKnown && elementIndex > maxElements)
1605 maxElements = elementIndex;
1607 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1608 // If this is an incomplete array type, the actual type needs to
1609 // be calculated here.
1610 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1611 if (maxElements == Zero) {
1612 // Sizing an array implicitly to zero is not allowed by ISO C,
1613 // but is supported by GNU.
1614 SemaRef.Diag(IList->getLocStart(),
1615 diag::ext_typecheck_zero_array_size);
1618 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1619 ArrayType::Normal, 0);
1621 if (!hadError && VerifyOnly) {
1622 // Check if there are any members of the array that get value-initialized.
1623 // If so, check if doing that is possible.
1624 // FIXME: This needs to detect holes left by designated initializers too.
1625 if (maxElementsKnown && elementIndex < maxElements)
1626 CheckEmptyInitializable(InitializedEntity::InitializeElement(
1627 SemaRef.Context, 0, Entity),
1628 IList->getLocEnd());
1632 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1635 bool TopLevelObject) {
1636 // Handle GNU flexible array initializers.
1637 unsigned FlexArrayDiag;
1638 if (isa<InitListExpr>(InitExpr) &&
1639 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1640 // Empty flexible array init always allowed as an extension
1641 FlexArrayDiag = diag::ext_flexible_array_init;
1642 } else if (SemaRef.getLangOpts().CPlusPlus) {
1643 // Disallow flexible array init in C++; it is not required for gcc
1644 // compatibility, and it needs work to IRGen correctly in general.
1645 FlexArrayDiag = diag::err_flexible_array_init;
1646 } else if (!TopLevelObject) {
1647 // Disallow flexible array init on non-top-level object
1648 FlexArrayDiag = diag::err_flexible_array_init;
1649 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1650 // Disallow flexible array init on anything which is not a variable.
1651 FlexArrayDiag = diag::err_flexible_array_init;
1652 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1653 // Disallow flexible array init on local variables.
1654 FlexArrayDiag = diag::err_flexible_array_init;
1656 // Allow other cases.
1657 FlexArrayDiag = diag::ext_flexible_array_init;
1661 SemaRef.Diag(InitExpr->getLocStart(),
1663 << InitExpr->getLocStart();
1664 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1668 return FlexArrayDiag != diag::ext_flexible_array_init;
1671 void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
1672 InitListExpr *IList,
1674 RecordDecl::field_iterator Field,
1675 bool SubobjectIsDesignatorContext,
1677 InitListExpr *StructuredList,
1678 unsigned &StructuredIndex,
1679 bool TopLevelObject) {
1680 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
1682 // If the record is invalid, some of it's members are invalid. To avoid
1683 // confusion, we forgo checking the intializer for the entire record.
1684 if (structDecl->isInvalidDecl()) {
1685 // Assume it was supposed to consume a single initializer.
1691 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1692 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1694 // If there's a default initializer, use it.
1695 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1698 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1699 Field != FieldEnd; ++Field) {
1700 if (Field->hasInClassInitializer()) {
1701 StructuredList->setInitializedFieldInUnion(*Field);
1702 // FIXME: Actually build a CXXDefaultInitExpr?
1708 // Value-initialize the first member of the union that isn't an unnamed
1710 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1711 Field != FieldEnd; ++Field) {
1712 if (!Field->isUnnamedBitfield()) {
1714 CheckEmptyInitializable(
1715 InitializedEntity::InitializeMember(*Field, &Entity),
1716 IList->getLocEnd());
1718 StructuredList->setInitializedFieldInUnion(*Field);
1725 // If structDecl is a forward declaration, this loop won't do
1726 // anything except look at designated initializers; That's okay,
1727 // because an error should get printed out elsewhere. It might be
1728 // worthwhile to skip over the rest of the initializer, though.
1729 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1730 RecordDecl::field_iterator FieldEnd = RD->field_end();
1731 bool InitializedSomething = false;
1732 bool CheckForMissingFields = true;
1733 while (Index < IList->getNumInits()) {
1734 Expr *Init = IList->getInit(Index);
1736 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1737 // If we're not the subobject that matches up with the '{' for
1738 // the designator, we shouldn't be handling the
1739 // designator. Return immediately.
1740 if (!SubobjectIsDesignatorContext)
1743 // Handle this designated initializer. Field will be updated to
1744 // the next field that we'll be initializing.
1745 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1746 DeclType, &Field, nullptr, Index,
1747 StructuredList, StructuredIndex,
1748 true, TopLevelObject))
1751 InitializedSomething = true;
1753 // Disable check for missing fields when designators are used.
1754 // This matches gcc behaviour.
1755 CheckForMissingFields = false;
1759 if (Field == FieldEnd) {
1760 // We've run out of fields. We're done.
1764 // We've already initialized a member of a union. We're done.
1765 if (InitializedSomething && DeclType->isUnionType())
1768 // If we've hit the flexible array member at the end, we're done.
1769 if (Field->getType()->isIncompleteArrayType())
1772 if (Field->isUnnamedBitfield()) {
1773 // Don't initialize unnamed bitfields, e.g. "int : 20;"
1778 // Make sure we can use this declaration.
1781 InvalidUse = !SemaRef.CanUseDecl(*Field);
1783 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1784 IList->getInit(Index)->getLocStart());
1792 InitializedEntity MemberEntity =
1793 InitializedEntity::InitializeMember(*Field, &Entity);
1794 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1795 StructuredList, StructuredIndex);
1796 InitializedSomething = true;
1798 if (DeclType->isUnionType() && !VerifyOnly) {
1799 // Initialize the first field within the union.
1800 StructuredList->setInitializedFieldInUnion(*Field);
1806 // Emit warnings for missing struct field initializers.
1807 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1808 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1809 !DeclType->isUnionType()) {
1810 // It is possible we have one or more unnamed bitfields remaining.
1811 // Find first (if any) named field and emit warning.
1812 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1814 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1815 SemaRef.Diag(IList->getSourceRange().getEnd(),
1816 diag::warn_missing_field_initializers) << *it;
1822 // Check that any remaining fields can be value-initialized.
1823 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1824 !Field->getType()->isIncompleteArrayType()) {
1825 // FIXME: Should check for holes left by designated initializers too.
1826 for (; Field != FieldEnd && !hadError; ++Field) {
1827 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1828 CheckEmptyInitializable(
1829 InitializedEntity::InitializeMember(*Field, &Entity),
1830 IList->getLocEnd());
1834 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1835 Index >= IList->getNumInits())
1838 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1845 InitializedEntity MemberEntity =
1846 InitializedEntity::InitializeMember(*Field, &Entity);
1848 if (isa<InitListExpr>(IList->getInit(Index)))
1849 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1850 StructuredList, StructuredIndex);
1852 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1853 StructuredList, StructuredIndex);
1856 /// \brief Expand a field designator that refers to a member of an
1857 /// anonymous struct or union into a series of field designators that
1858 /// refers to the field within the appropriate subobject.
1860 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1861 DesignatedInitExpr *DIE,
1863 IndirectFieldDecl *IndirectField) {
1864 typedef DesignatedInitExpr::Designator Designator;
1866 // Build the replacement designators.
1867 SmallVector<Designator, 4> Replacements;
1868 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1869 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1871 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1872 DIE->getDesignator(DesigIdx)->getDotLoc(),
1873 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1875 Replacements.push_back(Designator((IdentifierInfo *)nullptr,
1876 SourceLocation(), SourceLocation()));
1877 assert(isa<FieldDecl>(*PI));
1878 Replacements.back().setField(cast<FieldDecl>(*PI));
1881 // Expand the current designator into the set of replacement
1882 // designators, so we have a full subobject path down to where the
1883 // member of the anonymous struct/union is actually stored.
1884 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1885 &Replacements[0] + Replacements.size());
1888 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1889 DesignatedInitExpr *DIE) {
1890 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1891 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1892 for (unsigned I = 0; I < NumIndexExprs; ++I)
1893 IndexExprs[I] = DIE->getSubExpr(I + 1);
1894 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
1895 DIE->size(), IndexExprs,
1896 DIE->getEqualOrColonLoc(),
1897 DIE->usesGNUSyntax(), DIE->getInit());
1902 // Callback to only accept typo corrections that are for field members of
1903 // the given struct or union.
1904 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1906 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1909 bool ValidateCandidate(const TypoCorrection &candidate) override {
1910 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1911 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1920 /// @brief Check the well-formedness of a C99 designated initializer.
1922 /// Determines whether the designated initializer @p DIE, which
1923 /// resides at the given @p Index within the initializer list @p
1924 /// IList, is well-formed for a current object of type @p DeclType
1925 /// (C99 6.7.8). The actual subobject that this designator refers to
1926 /// within the current subobject is returned in either
1927 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1929 /// @param IList The initializer list in which this designated
1930 /// initializer occurs.
1932 /// @param DIE The designated initializer expression.
1934 /// @param DesigIdx The index of the current designator.
1936 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
1937 /// into which the designation in @p DIE should refer.
1939 /// @param NextField If non-NULL and the first designator in @p DIE is
1940 /// a field, this will be set to the field declaration corresponding
1941 /// to the field named by the designator.
1943 /// @param NextElementIndex If non-NULL and the first designator in @p
1944 /// DIE is an array designator or GNU array-range designator, this
1945 /// will be set to the last index initialized by this designator.
1947 /// @param Index Index into @p IList where the designated initializer
1950 /// @param StructuredList The initializer list expression that
1951 /// describes all of the subobject initializers in the order they'll
1952 /// actually be initialized.
1954 /// @returns true if there was an error, false otherwise.
1956 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
1957 InitListExpr *IList,
1958 DesignatedInitExpr *DIE,
1960 QualType &CurrentObjectType,
1961 RecordDecl::field_iterator *NextField,
1962 llvm::APSInt *NextElementIndex,
1964 InitListExpr *StructuredList,
1965 unsigned &StructuredIndex,
1966 bool FinishSubobjectInit,
1967 bool TopLevelObject) {
1968 if (DesigIdx == DIE->size()) {
1969 // Check the actual initialization for the designated object type.
1970 bool prevHadError = hadError;
1972 // Temporarily remove the designator expression from the
1973 // initializer list that the child calls see, so that we don't try
1974 // to re-process the designator.
1975 unsigned OldIndex = Index;
1976 IList->setInit(OldIndex, DIE->getInit());
1978 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
1979 StructuredList, StructuredIndex);
1981 // Restore the designated initializer expression in the syntactic
1982 // form of the initializer list.
1983 if (IList->getInit(OldIndex) != DIE->getInit())
1984 DIE->setInit(IList->getInit(OldIndex));
1985 IList->setInit(OldIndex, DIE);
1987 return hadError && !prevHadError;
1990 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
1991 bool IsFirstDesignator = (DesigIdx == 0);
1993 assert((IsFirstDesignator || StructuredList) &&
1994 "Need a non-designated initializer list to start from");
1996 // Determine the structural initializer list that corresponds to the
1997 // current subobject.
1998 if (IsFirstDesignator)
1999 StructuredList = SyntacticToSemantic.lookup(IList);
2001 Expr *ExistingInit = StructuredIndex < StructuredList->getNumInits() ?
2002 StructuredList->getInit(StructuredIndex) : nullptr;
2003 if (!ExistingInit && StructuredList->hasArrayFiller())
2004 ExistingInit = StructuredList->getArrayFiller();
2008 getStructuredSubobjectInit(IList, Index, CurrentObjectType,
2009 StructuredList, StructuredIndex,
2010 SourceRange(D->getLocStart(),
2012 else if (InitListExpr *Result = dyn_cast<InitListExpr>(ExistingInit))
2013 StructuredList = Result;
2015 if (DesignatedInitUpdateExpr *E =
2016 dyn_cast<DesignatedInitUpdateExpr>(ExistingInit))
2017 StructuredList = E->getUpdater();
2019 DesignatedInitUpdateExpr *DIUE =
2020 new (SemaRef.Context) DesignatedInitUpdateExpr(SemaRef.Context,
2021 D->getLocStart(), ExistingInit,
2023 StructuredList->updateInit(SemaRef.Context, StructuredIndex, DIUE);
2024 StructuredList = DIUE->getUpdater();
2027 // We need to check on source range validity because the previous
2028 // initializer does not have to be an explicit initializer. e.g.,
2030 // struct P { int a, b; };
2031 // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2033 // There is an overwrite taking place because the first braced initializer
2034 // list "{ .a = 2 }" already provides value for .p.b (which is zero).
2035 if (ExistingInit->getSourceRange().isValid()) {
2036 // We are creating an initializer list that initializes the
2037 // subobjects of the current object, but there was already an
2038 // initialization that completely initialized the current
2039 // subobject, e.g., by a compound literal:
2041 // struct X { int a, b; };
2042 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2044 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2045 // designated initializer re-initializes the whole
2046 // subobject [0], overwriting previous initializers.
2047 SemaRef.Diag(D->getLocStart(),
2048 diag::warn_subobject_initializer_overrides)
2049 << SourceRange(D->getLocStart(), DIE->getLocEnd());
2051 SemaRef.Diag(ExistingInit->getLocStart(),
2052 diag::note_previous_initializer)
2053 << /*FIXME:has side effects=*/0
2054 << ExistingInit->getSourceRange();
2058 assert(StructuredList && "Expected a structured initializer list");
2061 if (D->isFieldDesignator()) {
2064 // If a designator has the form
2068 // then the current object (defined below) shall have
2069 // structure or union type and the identifier shall be the
2070 // name of a member of that type.
2071 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
2073 SourceLocation Loc = D->getDotLoc();
2074 if (Loc.isInvalid())
2075 Loc = D->getFieldLoc();
2077 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
2078 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
2083 FieldDecl *KnownField = D->getField();
2085 IdentifierInfo *FieldName = D->getFieldName();
2086 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
2087 for (NamedDecl *ND : Lookup) {
2088 if (auto *FD = dyn_cast<FieldDecl>(ND)) {
2092 if (auto *IFD = dyn_cast<IndirectFieldDecl>(ND)) {
2093 // In verify mode, don't modify the original.
2095 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
2096 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
2097 D = DIE->getDesignator(DesigIdx);
2098 KnownField = cast<FieldDecl>(*IFD->chain_begin());
2105 return true; // No typo correction when just trying this out.
2108 // Name lookup found something, but it wasn't a field.
2109 if (!Lookup.empty()) {
2110 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
2112 SemaRef.Diag(Lookup.front()->getLocation(),
2113 diag::note_field_designator_found);
2118 // Name lookup didn't find anything.
2119 // Determine whether this was a typo for another field name.
2120 if (TypoCorrection Corrected = SemaRef.CorrectTypo(
2121 DeclarationNameInfo(FieldName, D->getFieldLoc()),
2122 Sema::LookupMemberName, /*Scope=*/nullptr, /*SS=*/nullptr,
2123 llvm::make_unique<FieldInitializerValidatorCCC>(RT->getDecl()),
2124 Sema::CTK_ErrorRecovery, RT->getDecl())) {
2125 SemaRef.diagnoseTypo(
2127 SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
2128 << FieldName << CurrentObjectType);
2129 KnownField = Corrected.getCorrectionDeclAs<FieldDecl>();
2132 // Typo correction didn't find anything.
2133 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
2134 << FieldName << CurrentObjectType;
2141 unsigned FieldIndex = 0;
2142 for (auto *FI : RT->getDecl()->fields()) {
2143 if (FI->isUnnamedBitfield())
2145 if (KnownField == FI)
2150 RecordDecl::field_iterator Field =
2151 RecordDecl::field_iterator(DeclContext::decl_iterator(KnownField));
2153 // All of the fields of a union are located at the same place in
2154 // the initializer list.
2155 if (RT->getDecl()->isUnion()) {
2158 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
2159 if (CurrentField && CurrentField != *Field) {
2160 assert(StructuredList->getNumInits() == 1
2161 && "A union should never have more than one initializer!");
2163 // we're about to throw away an initializer, emit warning
2164 SemaRef.Diag(D->getFieldLoc(),
2165 diag::warn_initializer_overrides)
2166 << D->getSourceRange();
2167 Expr *ExistingInit = StructuredList->getInit(0);
2168 SemaRef.Diag(ExistingInit->getLocStart(),
2169 diag::note_previous_initializer)
2170 << /*FIXME:has side effects=*/0
2171 << ExistingInit->getSourceRange();
2173 // remove existing initializer
2174 StructuredList->resizeInits(SemaRef.Context, 0);
2175 StructuredList->setInitializedFieldInUnion(nullptr);
2178 StructuredList->setInitializedFieldInUnion(*Field);
2182 // Make sure we can use this declaration.
2185 InvalidUse = !SemaRef.CanUseDecl(*Field);
2187 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
2194 // Update the designator with the field declaration.
2195 D->setField(*Field);
2197 // Make sure that our non-designated initializer list has space
2198 // for a subobject corresponding to this field.
2199 if (FieldIndex >= StructuredList->getNumInits())
2200 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
2203 // This designator names a flexible array member.
2204 if (Field->getType()->isIncompleteArrayType()) {
2205 bool Invalid = false;
2206 if ((DesigIdx + 1) != DIE->size()) {
2207 // We can't designate an object within the flexible array
2208 // member (because GCC doesn't allow it).
2210 DesignatedInitExpr::Designator *NextD
2211 = DIE->getDesignator(DesigIdx + 1);
2212 SemaRef.Diag(NextD->getLocStart(),
2213 diag::err_designator_into_flexible_array_member)
2214 << SourceRange(NextD->getLocStart(),
2216 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2222 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
2223 !isa<StringLiteral>(DIE->getInit())) {
2224 // The initializer is not an initializer list.
2226 SemaRef.Diag(DIE->getInit()->getLocStart(),
2227 diag::err_flexible_array_init_needs_braces)
2228 << DIE->getInit()->getSourceRange();
2229 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
2235 // Check GNU flexible array initializer.
2236 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
2245 // Initialize the array.
2246 bool prevHadError = hadError;
2247 unsigned newStructuredIndex = FieldIndex;
2248 unsigned OldIndex = Index;
2249 IList->setInit(Index, DIE->getInit());
2251 InitializedEntity MemberEntity =
2252 InitializedEntity::InitializeMember(*Field, &Entity);
2253 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
2254 StructuredList, newStructuredIndex);
2256 IList->setInit(OldIndex, DIE);
2257 if (hadError && !prevHadError) {
2262 StructuredIndex = FieldIndex;
2266 // Recurse to check later designated subobjects.
2267 QualType FieldType = Field->getType();
2268 unsigned newStructuredIndex = FieldIndex;
2270 InitializedEntity MemberEntity =
2271 InitializedEntity::InitializeMember(*Field, &Entity);
2272 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
2273 FieldType, nullptr, nullptr, Index,
2274 StructuredList, newStructuredIndex,
2279 // Find the position of the next field to be initialized in this
2284 // If this the first designator, our caller will continue checking
2285 // the rest of this struct/class/union subobject.
2286 if (IsFirstDesignator) {
2289 StructuredIndex = FieldIndex;
2293 if (!FinishSubobjectInit)
2296 // We've already initialized something in the union; we're done.
2297 if (RT->getDecl()->isUnion())
2300 // Check the remaining fields within this class/struct/union subobject.
2301 bool prevHadError = hadError;
2303 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
2304 StructuredList, FieldIndex);
2305 return hadError && !prevHadError;
2310 // If a designator has the form
2312 // [ constant-expression ]
2314 // then the current object (defined below) shall have array
2315 // type and the expression shall be an integer constant
2316 // expression. If the array is of unknown size, any
2317 // nonnegative value is valid.
2319 // Additionally, cope with the GNU extension that permits
2320 // designators of the form
2322 // [ constant-expression ... constant-expression ]
2323 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2326 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2327 << CurrentObjectType;
2332 Expr *IndexExpr = nullptr;
2333 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2334 if (D->isArrayDesignator()) {
2335 IndexExpr = DIE->getArrayIndex(*D);
2336 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2337 DesignatedEndIndex = DesignatedStartIndex;
2339 assert(D->isArrayRangeDesignator() && "Need array-range designator");
2341 DesignatedStartIndex =
2342 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
2343 DesignatedEndIndex =
2344 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2345 IndexExpr = DIE->getArrayRangeEnd(*D);
2347 // Codegen can't handle evaluating array range designators that have side
2348 // effects, because we replicate the AST value for each initialized element.
2349 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2350 // elements with something that has a side effect, so codegen can emit an
2351 // "error unsupported" error instead of miscompiling the app.
2352 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2353 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2354 FullyStructuredList->sawArrayRangeDesignator();
2357 if (isa<ConstantArrayType>(AT)) {
2358 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2359 DesignatedStartIndex
2360 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2361 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2363 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2364 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2365 if (DesignatedEndIndex >= MaxElements) {
2367 SemaRef.Diag(IndexExpr->getLocStart(),
2368 diag::err_array_designator_too_large)
2369 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2370 << IndexExpr->getSourceRange();
2375 unsigned DesignatedIndexBitWidth =
2376 ConstantArrayType::getMaxSizeBits(SemaRef.Context);
2377 DesignatedStartIndex =
2378 DesignatedStartIndex.extOrTrunc(DesignatedIndexBitWidth);
2379 DesignatedEndIndex =
2380 DesignatedEndIndex.extOrTrunc(DesignatedIndexBitWidth);
2381 DesignatedStartIndex.setIsUnsigned(true);
2382 DesignatedEndIndex.setIsUnsigned(true);
2385 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2386 // We're modifying a string literal init; we have to decompose the string
2387 // so we can modify the individual characters.
2388 ASTContext &Context = SemaRef.Context;
2389 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2391 // Compute the character type
2392 QualType CharTy = AT->getElementType();
2394 // Compute the type of the integer literals.
2395 QualType PromotedCharTy = CharTy;
2396 if (CharTy->isPromotableIntegerType())
2397 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2398 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2400 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2401 // Get the length of the string.
2402 uint64_t StrLen = SL->getLength();
2403 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2404 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2405 StructuredList->resizeInits(Context, StrLen);
2407 // Build a literal for each character in the string, and put them into
2409 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2410 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2411 Expr *Init = new (Context) IntegerLiteral(
2412 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2413 if (CharTy != PromotedCharTy)
2414 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2415 Init, nullptr, VK_RValue);
2416 StructuredList->updateInit(Context, i, Init);
2419 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2421 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2423 // Get the length of the string.
2424 uint64_t StrLen = Str.size();
2425 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2426 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2427 StructuredList->resizeInits(Context, StrLen);
2429 // Build a literal for each character in the string, and put them into
2431 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2432 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2433 Expr *Init = new (Context) IntegerLiteral(
2434 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2435 if (CharTy != PromotedCharTy)
2436 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2437 Init, nullptr, VK_RValue);
2438 StructuredList->updateInit(Context, i, Init);
2443 // Make sure that our non-designated initializer list has space
2444 // for a subobject corresponding to this array element.
2446 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2447 StructuredList->resizeInits(SemaRef.Context,
2448 DesignatedEndIndex.getZExtValue() + 1);
2450 // Repeatedly perform subobject initializations in the range
2451 // [DesignatedStartIndex, DesignatedEndIndex].
2453 // Move to the next designator
2454 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2455 unsigned OldIndex = Index;
2457 InitializedEntity ElementEntity =
2458 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2460 while (DesignatedStartIndex <= DesignatedEndIndex) {
2461 // Recurse to check later designated subobjects.
2462 QualType ElementType = AT->getElementType();
2465 ElementEntity.setElementIndex(ElementIndex);
2466 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2467 ElementType, nullptr, nullptr, Index,
2468 StructuredList, ElementIndex,
2469 (DesignatedStartIndex == DesignatedEndIndex),
2473 // Move to the next index in the array that we'll be initializing.
2474 ++DesignatedStartIndex;
2475 ElementIndex = DesignatedStartIndex.getZExtValue();
2478 // If this the first designator, our caller will continue checking
2479 // the rest of this array subobject.
2480 if (IsFirstDesignator) {
2481 if (NextElementIndex)
2482 *NextElementIndex = DesignatedStartIndex;
2483 StructuredIndex = ElementIndex;
2487 if (!FinishSubobjectInit)
2490 // Check the remaining elements within this array subobject.
2491 bool prevHadError = hadError;
2492 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2493 /*SubobjectIsDesignatorContext=*/false, Index,
2494 StructuredList, ElementIndex);
2495 return hadError && !prevHadError;
2498 // Get the structured initializer list for a subobject of type
2499 // @p CurrentObjectType.
2501 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2502 QualType CurrentObjectType,
2503 InitListExpr *StructuredList,
2504 unsigned StructuredIndex,
2505 SourceRange InitRange,
2506 bool IsFullyOverwritten) {
2508 return nullptr; // No structured list in verification-only mode.
2509 Expr *ExistingInit = nullptr;
2510 if (!StructuredList)
2511 ExistingInit = SyntacticToSemantic.lookup(IList);
2512 else if (StructuredIndex < StructuredList->getNumInits())
2513 ExistingInit = StructuredList->getInit(StructuredIndex);
2515 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2516 // There might have already been initializers for subobjects of the current
2517 // object, but a subsequent initializer list will overwrite the entirety
2518 // of the current object. (See DR 253 and C99 6.7.8p21). e.g.,
2520 // struct P { char x[6]; };
2521 // struct P l = { .x[2] = 'x', .x = { [0] = 'f' } };
2523 // The first designated initializer is ignored, and l.x is just "f".
2524 if (!IsFullyOverwritten)
2528 // We are creating an initializer list that initializes the
2529 // subobjects of the current object, but there was already an
2530 // initialization that completely initialized the current
2531 // subobject, e.g., by a compound literal:
2533 // struct X { int a, b; };
2534 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2536 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2537 // designated initializer re-initializes the whole
2538 // subobject [0], overwriting previous initializers.
2539 SemaRef.Diag(InitRange.getBegin(),
2540 diag::warn_subobject_initializer_overrides)
2542 SemaRef.Diag(ExistingInit->getLocStart(),
2543 diag::note_previous_initializer)
2544 << /*FIXME:has side effects=*/0
2545 << ExistingInit->getSourceRange();
2548 InitListExpr *Result
2549 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2550 InitRange.getBegin(), None,
2551 InitRange.getEnd());
2553 QualType ResultType = CurrentObjectType;
2554 if (!ResultType->isArrayType())
2555 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2556 Result->setType(ResultType);
2558 // Pre-allocate storage for the structured initializer list.
2559 unsigned NumElements = 0;
2560 unsigned NumInits = 0;
2561 bool GotNumInits = false;
2562 if (!StructuredList) {
2563 NumInits = IList->getNumInits();
2565 } else if (Index < IList->getNumInits()) {
2566 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2567 NumInits = SubList->getNumInits();
2572 if (const ArrayType *AType
2573 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2574 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2575 NumElements = CAType->getSize().getZExtValue();
2576 // Simple heuristic so that we don't allocate a very large
2577 // initializer with many empty entries at the end.
2578 if (GotNumInits && NumElements > NumInits)
2581 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2582 NumElements = VType->getNumElements();
2583 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2584 RecordDecl *RDecl = RType->getDecl();
2585 if (RDecl->isUnion())
2588 NumElements = std::distance(RDecl->field_begin(), RDecl->field_end());
2591 Result->reserveInits(SemaRef.Context, NumElements);
2593 // Link this new initializer list into the structured initializer
2596 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2598 Result->setSyntacticForm(IList);
2599 SyntacticToSemantic[IList] = Result;
2605 /// Update the initializer at index @p StructuredIndex within the
2606 /// structured initializer list to the value @p expr.
2607 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2608 unsigned &StructuredIndex,
2610 // No structured initializer list to update
2611 if (!StructuredList)
2614 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2615 StructuredIndex, expr)) {
2616 // This initializer overwrites a previous initializer. Warn.
2617 // We need to check on source range validity because the previous
2618 // initializer does not have to be an explicit initializer.
2619 // struct P { int a, b; };
2620 // struct PP { struct P p } l = { { .a = 2 }, .p.b = 3 };
2621 // There is an overwrite taking place because the first braced initializer
2622 // list "{ .a = 2 }' already provides value for .p.b (which is zero).
2623 if (PrevInit->getSourceRange().isValid()) {
2624 SemaRef.Diag(expr->getLocStart(),
2625 diag::warn_initializer_overrides)
2626 << expr->getSourceRange();
2628 SemaRef.Diag(PrevInit->getLocStart(),
2629 diag::note_previous_initializer)
2630 << /*FIXME:has side effects=*/0
2631 << PrevInit->getSourceRange();
2638 /// Check that the given Index expression is a valid array designator
2639 /// value. This is essentially just a wrapper around
2640 /// VerifyIntegerConstantExpression that also checks for negative values
2641 /// and produces a reasonable diagnostic if there is a
2642 /// failure. Returns the index expression, possibly with an implicit cast
2643 /// added, on success. If everything went okay, Value will receive the
2644 /// value of the constant expression.
2646 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2647 SourceLocation Loc = Index->getLocStart();
2649 // Make sure this is an integer constant expression.
2650 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2651 if (Result.isInvalid())
2654 if (Value.isSigned() && Value.isNegative())
2655 return S.Diag(Loc, diag::err_array_designator_negative)
2656 << Value.toString(10) << Index->getSourceRange();
2658 Value.setIsUnsigned(true);
2662 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2666 typedef DesignatedInitExpr::Designator ASTDesignator;
2668 bool Invalid = false;
2669 SmallVector<ASTDesignator, 32> Designators;
2670 SmallVector<Expr *, 32> InitExpressions;
2672 // Build designators and check array designator expressions.
2673 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2674 const Designator &D = Desig.getDesignator(Idx);
2675 switch (D.getKind()) {
2676 case Designator::FieldDesignator:
2677 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2681 case Designator::ArrayDesignator: {
2682 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2683 llvm::APSInt IndexValue;
2684 if (!Index->isTypeDependent() && !Index->isValueDependent())
2685 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).get();
2689 Designators.push_back(ASTDesignator(InitExpressions.size(),
2691 D.getRBracketLoc()));
2692 InitExpressions.push_back(Index);
2697 case Designator::ArrayRangeDesignator: {
2698 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2699 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2700 llvm::APSInt StartValue;
2701 llvm::APSInt EndValue;
2702 bool StartDependent = StartIndex->isTypeDependent() ||
2703 StartIndex->isValueDependent();
2704 bool EndDependent = EndIndex->isTypeDependent() ||
2705 EndIndex->isValueDependent();
2706 if (!StartDependent)
2708 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).get();
2710 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).get();
2712 if (!StartIndex || !EndIndex)
2715 // Make sure we're comparing values with the same bit width.
2716 if (StartDependent || EndDependent) {
2717 // Nothing to compute.
2718 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2719 EndValue = EndValue.extend(StartValue.getBitWidth());
2720 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2721 StartValue = StartValue.extend(EndValue.getBitWidth());
2723 if (!StartDependent && !EndDependent && EndValue < StartValue) {
2724 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2725 << StartValue.toString(10) << EndValue.toString(10)
2726 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2729 Designators.push_back(ASTDesignator(InitExpressions.size(),
2732 D.getRBracketLoc()));
2733 InitExpressions.push_back(StartIndex);
2734 InitExpressions.push_back(EndIndex);
2742 if (Invalid || Init.isInvalid())
2745 // Clear out the expressions within the designation.
2746 Desig.ClearExprs(*this);
2748 DesignatedInitExpr *DIE
2749 = DesignatedInitExpr::Create(Context,
2750 Designators.data(), Designators.size(),
2751 InitExpressions, Loc, GNUSyntax,
2752 Init.getAs<Expr>());
2754 if (!getLangOpts().C99)
2755 Diag(DIE->getLocStart(), diag::ext_designated_init)
2756 << DIE->getSourceRange();
2761 //===----------------------------------------------------------------------===//
2762 // Initialization entity
2763 //===----------------------------------------------------------------------===//
2765 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2766 const InitializedEntity &Parent)
2767 : Parent(&Parent), Index(Index)
2769 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2770 Kind = EK_ArrayElement;
2771 Type = AT->getElementType();
2772 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2773 Kind = EK_VectorElement;
2774 Type = VT->getElementType();
2776 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2777 assert(CT && "Unexpected type");
2778 Kind = EK_ComplexElement;
2779 Type = CT->getElementType();
2784 InitializedEntity::InitializeBase(ASTContext &Context,
2785 const CXXBaseSpecifier *Base,
2786 bool IsInheritedVirtualBase) {
2787 InitializedEntity Result;
2788 Result.Kind = EK_Base;
2789 Result.Parent = nullptr;
2790 Result.Base = reinterpret_cast<uintptr_t>(Base);
2791 if (IsInheritedVirtualBase)
2792 Result.Base |= 0x01;
2794 Result.Type = Base->getType();
2798 DeclarationName InitializedEntity::getName() const {
2799 switch (getKind()) {
2801 case EK_Parameter_CF_Audited: {
2802 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2803 return (D ? D->getDeclName() : DeclarationName());
2808 return VariableOrMember->getDeclName();
2810 case EK_LambdaCapture:
2811 return DeclarationName(Capture.VarID);
2819 case EK_ArrayElement:
2820 case EK_VectorElement:
2821 case EK_ComplexElement:
2822 case EK_BlockElement:
2823 case EK_CompoundLiteralInit:
2824 case EK_RelatedResult:
2825 return DeclarationName();
2828 llvm_unreachable("Invalid EntityKind!");
2831 DeclaratorDecl *InitializedEntity::getDecl() const {
2832 switch (getKind()) {
2835 return VariableOrMember;
2838 case EK_Parameter_CF_Audited:
2839 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2847 case EK_ArrayElement:
2848 case EK_VectorElement:
2849 case EK_ComplexElement:
2850 case EK_BlockElement:
2851 case EK_LambdaCapture:
2852 case EK_CompoundLiteralInit:
2853 case EK_RelatedResult:
2857 llvm_unreachable("Invalid EntityKind!");
2860 bool InitializedEntity::allowsNRVO() const {
2861 switch (getKind()) {
2864 return LocAndNRVO.NRVO;
2868 case EK_Parameter_CF_Audited:
2872 case EK_CompoundLiteralInit:
2875 case EK_ArrayElement:
2876 case EK_VectorElement:
2877 case EK_ComplexElement:
2878 case EK_BlockElement:
2879 case EK_LambdaCapture:
2880 case EK_RelatedResult:
2887 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2888 assert(getParent() != this);
2889 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2890 for (unsigned I = 0; I != Depth; ++I)
2893 switch (getKind()) {
2894 case EK_Variable: OS << "Variable"; break;
2895 case EK_Parameter: OS << "Parameter"; break;
2896 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2898 case EK_Result: OS << "Result"; break;
2899 case EK_Exception: OS << "Exception"; break;
2900 case EK_Member: OS << "Member"; break;
2901 case EK_New: OS << "New"; break;
2902 case EK_Temporary: OS << "Temporary"; break;
2903 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2904 case EK_RelatedResult: OS << "RelatedResult"; break;
2905 case EK_Base: OS << "Base"; break;
2906 case EK_Delegating: OS << "Delegating"; break;
2907 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2908 case EK_VectorElement: OS << "VectorElement " << Index; break;
2909 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2910 case EK_BlockElement: OS << "Block"; break;
2911 case EK_LambdaCapture:
2912 OS << "LambdaCapture ";
2913 OS << DeclarationName(Capture.VarID);
2917 if (Decl *D = getDecl()) {
2919 cast<NamedDecl>(D)->printQualifiedName(OS);
2922 OS << " '" << getType().getAsString() << "'\n";
2927 void InitializedEntity::dump() const {
2928 dumpImpl(llvm::errs());
2931 //===----------------------------------------------------------------------===//
2932 // Initialization sequence
2933 //===----------------------------------------------------------------------===//
2935 void InitializationSequence::Step::Destroy() {
2937 case SK_ResolveAddressOfOverloadedFunction:
2938 case SK_CastDerivedToBaseRValue:
2939 case SK_CastDerivedToBaseXValue:
2940 case SK_CastDerivedToBaseLValue:
2941 case SK_BindReference:
2942 case SK_BindReferenceToTemporary:
2943 case SK_ExtraneousCopyToTemporary:
2944 case SK_UserConversion:
2945 case SK_QualificationConversionRValue:
2946 case SK_QualificationConversionXValue:
2947 case SK_QualificationConversionLValue:
2948 case SK_AtomicConversion:
2949 case SK_LValueToRValue:
2950 case SK_ListInitialization:
2951 case SK_UnwrapInitList:
2952 case SK_RewrapInitList:
2953 case SK_ConstructorInitialization:
2954 case SK_ConstructorInitializationFromList:
2955 case SK_ZeroInitialization:
2956 case SK_CAssignment:
2958 case SK_ObjCObjectConversion:
2960 case SK_ParenthesizedArrayInit:
2961 case SK_PassByIndirectCopyRestore:
2962 case SK_PassByIndirectRestore:
2963 case SK_ProduceObjCObject:
2964 case SK_StdInitializerList:
2965 case SK_StdInitializerListConstructorCall:
2966 case SK_OCLSamplerInit:
2967 case SK_OCLZeroEvent:
2970 case SK_ConversionSequence:
2971 case SK_ConversionSequenceNoNarrowing:
2976 bool InitializationSequence::isDirectReferenceBinding() const {
2977 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
2980 bool InitializationSequence::isAmbiguous() const {
2984 switch (getFailureKind()) {
2985 case FK_TooManyInitsForReference:
2986 case FK_ArrayNeedsInitList:
2987 case FK_ArrayNeedsInitListOrStringLiteral:
2988 case FK_ArrayNeedsInitListOrWideStringLiteral:
2989 case FK_NarrowStringIntoWideCharArray:
2990 case FK_WideStringIntoCharArray:
2991 case FK_IncompatWideStringIntoWideChar:
2992 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2993 case FK_NonConstLValueReferenceBindingToTemporary:
2994 case FK_NonConstLValueReferenceBindingToUnrelated:
2995 case FK_RValueReferenceBindingToLValue:
2996 case FK_ReferenceInitDropsQualifiers:
2997 case FK_ReferenceInitFailed:
2998 case FK_ConversionFailed:
2999 case FK_ConversionFromPropertyFailed:
3000 case FK_TooManyInitsForScalar:
3001 case FK_ReferenceBindingToInitList:
3002 case FK_InitListBadDestinationType:
3003 case FK_DefaultInitOfConst:
3005 case FK_ArrayTypeMismatch:
3006 case FK_NonConstantArrayInit:
3007 case FK_ListInitializationFailed:
3008 case FK_VariableLengthArrayHasInitializer:
3009 case FK_PlaceholderType:
3010 case FK_ExplicitConstructor:
3013 case FK_ReferenceInitOverloadFailed:
3014 case FK_UserConversionOverloadFailed:
3015 case FK_ConstructorOverloadFailed:
3016 case FK_ListConstructorOverloadFailed:
3017 return FailedOverloadResult == OR_Ambiguous;
3020 llvm_unreachable("Invalid EntityKind!");
3023 bool InitializationSequence::isConstructorInitialization() const {
3024 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
3028 InitializationSequence
3029 ::AddAddressOverloadResolutionStep(FunctionDecl *Function,
3030 DeclAccessPair Found,
3031 bool HadMultipleCandidates) {
3033 S.Kind = SK_ResolveAddressOfOverloadedFunction;
3034 S.Type = Function->getType();
3035 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3036 S.Function.Function = Function;
3037 S.Function.FoundDecl = Found;
3041 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
3045 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
3046 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
3047 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
3053 void InitializationSequence::AddReferenceBindingStep(QualType T,
3054 bool BindingTemporary) {
3056 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
3061 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
3063 S.Kind = SK_ExtraneousCopyToTemporary;
3069 InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
3070 DeclAccessPair FoundDecl,
3072 bool HadMultipleCandidates) {
3074 S.Kind = SK_UserConversion;
3076 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3077 S.Function.Function = Function;
3078 S.Function.FoundDecl = FoundDecl;
3082 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
3085 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
3088 S.Kind = SK_QualificationConversionRValue;
3091 S.Kind = SK_QualificationConversionXValue;
3094 S.Kind = SK_QualificationConversionLValue;
3101 void InitializationSequence::AddAtomicConversionStep(QualType Ty) {
3103 S.Kind = SK_AtomicConversion;
3108 void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
3109 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
3112 S.Kind = SK_LValueToRValue;
3117 void InitializationSequence::AddConversionSequenceStep(
3118 const ImplicitConversionSequence &ICS, QualType T,
3119 bool TopLevelOfInitList) {
3121 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
3122 : SK_ConversionSequence;
3124 S.ICS = new ImplicitConversionSequence(ICS);
3128 void InitializationSequence::AddListInitializationStep(QualType T) {
3130 S.Kind = SK_ListInitialization;
3136 InitializationSequence
3137 ::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
3138 AccessSpecifier Access,
3140 bool HadMultipleCandidates,
3141 bool FromInitList, bool AsInitList) {
3143 S.Kind = FromInitList ? AsInitList ? SK_StdInitializerListConstructorCall
3144 : SK_ConstructorInitializationFromList
3145 : SK_ConstructorInitialization;
3147 S.Function.HadMultipleCandidates = HadMultipleCandidates;
3148 S.Function.Function = Constructor;
3149 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
3153 void InitializationSequence::AddZeroInitializationStep(QualType T) {
3155 S.Kind = SK_ZeroInitialization;
3160 void InitializationSequence::AddCAssignmentStep(QualType T) {
3162 S.Kind = SK_CAssignment;
3167 void InitializationSequence::AddStringInitStep(QualType T) {
3169 S.Kind = SK_StringInit;
3174 void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
3176 S.Kind = SK_ObjCObjectConversion;
3181 void InitializationSequence::AddArrayInitStep(QualType T) {
3183 S.Kind = SK_ArrayInit;
3188 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
3190 S.Kind = SK_ParenthesizedArrayInit;
3195 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
3198 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
3199 : SK_PassByIndirectRestore);
3204 void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
3206 S.Kind = SK_ProduceObjCObject;
3211 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
3213 S.Kind = SK_StdInitializerList;
3218 void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
3220 S.Kind = SK_OCLSamplerInit;
3225 void InitializationSequence::AddOCLZeroEventStep(QualType T) {
3227 S.Kind = SK_OCLZeroEvent;
3232 void InitializationSequence::RewrapReferenceInitList(QualType T,
3233 InitListExpr *Syntactic) {
3234 assert(Syntactic->getNumInits() == 1 &&
3235 "Can only rewrap trivial init lists.");
3237 S.Kind = SK_UnwrapInitList;
3238 S.Type = Syntactic->getInit(0)->getType();
3239 Steps.insert(Steps.begin(), S);
3241 S.Kind = SK_RewrapInitList;
3243 S.WrappingSyntacticList = Syntactic;
3247 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
3248 OverloadingResult Result) {
3249 setSequenceKind(FailedSequence);
3250 this->Failure = Failure;
3251 this->FailedOverloadResult = Result;
3254 //===----------------------------------------------------------------------===//
3255 // Attempt initialization
3256 //===----------------------------------------------------------------------===//
3258 /// Tries to add a zero initializer. Returns true if that worked.
3260 maybeRecoverWithZeroInitialization(Sema &S, InitializationSequence &Sequence,
3261 const InitializedEntity &Entity) {
3262 if (Entity.getKind() != InitializedEntity::EK_Variable)
3265 VarDecl *VD = cast<VarDecl>(Entity.getDecl());
3266 if (VD->getInit() || VD->getLocEnd().isMacroID())
3269 QualType VariableTy = VD->getType().getCanonicalType();
3270 SourceLocation Loc = S.getLocForEndOfToken(VD->getLocEnd());
3271 std::string Init = S.getFixItZeroInitializerForType(VariableTy, Loc);
3272 if (!Init.empty()) {
3273 Sequence.AddZeroInitializationStep(Entity.getType());
3274 Sequence.SetZeroInitializationFixit(Init, Loc);
3280 static void MaybeProduceObjCObject(Sema &S,
3281 InitializationSequence &Sequence,
3282 const InitializedEntity &Entity) {
3283 if (!S.getLangOpts().ObjCAutoRefCount) return;
3285 /// When initializing a parameter, produce the value if it's marked
3286 /// __attribute__((ns_consumed)).
3287 if (Entity.isParameterKind()) {
3288 if (!Entity.isParameterConsumed())
3291 assert(Entity.getType()->isObjCRetainableType() &&
3292 "consuming an object of unretainable type?");
3293 Sequence.AddProduceObjCObjectStep(Entity.getType());
3295 /// When initializing a return value, if the return type is a
3296 /// retainable type, then returns need to immediately retain the
3297 /// object. If an autorelease is required, it will be done at the
3299 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
3300 if (!Entity.getType()->isObjCRetainableType())
3303 Sequence.AddProduceObjCObjectStep(Entity.getType());
3307 static void TryListInitialization(Sema &S,
3308 const InitializedEntity &Entity,
3309 const InitializationKind &Kind,
3310 InitListExpr *InitList,
3311 InitializationSequence &Sequence);
3313 /// \brief When initializing from init list via constructor, handle
3314 /// initialization of an object of type std::initializer_list<T>.
3316 /// \return true if we have handled initialization of an object of type
3317 /// std::initializer_list<T>, false otherwise.
3318 static bool TryInitializerListConstruction(Sema &S,
3321 InitializationSequence &Sequence) {
3323 if (!S.isStdInitializerList(DestType, &E))
3326 if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
3327 Sequence.setIncompleteTypeFailure(E);
3331 // Try initializing a temporary array from the init list.
3332 QualType ArrayType = S.Context.getConstantArrayType(
3333 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3334 List->getNumInits()),
3335 clang::ArrayType::Normal, 0);
3336 InitializedEntity HiddenArray =
3337 InitializedEntity::InitializeTemporary(ArrayType);
3338 InitializationKind Kind =
3339 InitializationKind::CreateDirectList(List->getExprLoc());
3340 TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3342 Sequence.AddStdInitializerListConstructionStep(DestType);
3346 static OverloadingResult
3347 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
3349 OverloadCandidateSet &CandidateSet,
3350 DeclContext::lookup_result Ctors,
3351 OverloadCandidateSet::iterator &Best,
3352 bool CopyInitializing, bool AllowExplicit,
3353 bool OnlyListConstructors, bool IsListInit) {
3354 CandidateSet.clear();
3356 for (NamedDecl *D : Ctors) {
3357 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3358 bool SuppressUserConversions = false;
3360 // Find the constructor (which may be a template).
3361 CXXConstructorDecl *Constructor = nullptr;
3362 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3363 if (ConstructorTmpl)
3364 Constructor = cast<CXXConstructorDecl>(
3365 ConstructorTmpl->getTemplatedDecl());
3367 Constructor = cast<CXXConstructorDecl>(D);
3369 // C++11 [over.best.ics]p4:
3370 // ... and the constructor or user-defined conversion function is a
3372 // - 13.3.1.3, when the argument is the temporary in the second step
3373 // of a class copy-initialization, or
3374 // - 13.3.1.4, 13.3.1.5, or 13.3.1.6 (in all cases),
3375 // user-defined conversion sequences are not considered.
3376 // FIXME: This breaks backward compatibility, e.g. PR12117. As a
3377 // temporary fix, let's re-instate the third bullet above until
3378 // there is a resolution in the standard, i.e.,
3379 // - 13.3.1.7 when the initializer list has exactly one element that is
3380 // itself an initializer list and a conversion to some class X or
3381 // reference to (possibly cv-qualified) X is considered for the first
3382 // parameter of a constructor of X.
3383 if ((CopyInitializing ||
3384 (IsListInit && Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3385 Constructor->isCopyOrMoveConstructor())
3386 SuppressUserConversions = true;
3389 if (!Constructor->isInvalidDecl() &&
3390 (AllowExplicit || !Constructor->isExplicit()) &&
3391 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
3392 if (ConstructorTmpl)
3393 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3394 /*ExplicitArgs*/ nullptr, Args,
3395 CandidateSet, SuppressUserConversions);
3397 // C++ [over.match.copy]p1:
3398 // - When initializing a temporary to be bound to the first parameter
3399 // of a constructor that takes a reference to possibly cv-qualified
3400 // T as its first argument, called with a single argument in the
3401 // context of direct-initialization, explicit conversion functions
3402 // are also considered.
3403 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3405 Constructor->isCopyOrMoveConstructor();
3406 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
3407 SuppressUserConversions,
3408 /*PartialOverloading=*/false,
3409 /*AllowExplicit=*/AllowExplicitConv);
3414 // Perform overload resolution and return the result.
3415 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3418 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3419 /// enumerates the constructors of the initialized entity and performs overload
3420 /// resolution to select the best.
3421 /// \param IsListInit Is this list-initialization?
3422 /// \param IsInitListCopy Is this non-list-initialization resulting from a
3423 /// list-initialization from {x} where x is the same
3424 /// type as the entity?
3425 static void TryConstructorInitialization(Sema &S,
3426 const InitializedEntity &Entity,
3427 const InitializationKind &Kind,
3428 MultiExprArg Args, QualType DestType,
3429 InitializationSequence &Sequence,
3430 bool IsListInit = false,
3431 bool IsInitListCopy = false) {
3432 assert((!IsListInit || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3433 "IsListInit must come with a single initializer list argument.");
3435 // The type we're constructing needs to be complete.
3436 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
3437 Sequence.setIncompleteTypeFailure(DestType);
3441 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3442 assert(DestRecordType && "Constructor initialization requires record type");
3443 CXXRecordDecl *DestRecordDecl
3444 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3446 // Build the candidate set directly in the initialization sequence
3447 // structure, so that it will persist if we fail.
3448 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3450 // Determine whether we are allowed to call explicit constructors or
3451 // explicit conversion operators.
3452 bool AllowExplicit = Kind.AllowExplicit() || IsListInit;
3453 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3455 // - Otherwise, if T is a class type, constructors are considered. The
3456 // applicable constructors are enumerated, and the best one is chosen
3457 // through overload resolution.
3458 DeclContext::lookup_result Ctors = S.LookupConstructors(DestRecordDecl);
3460 OverloadingResult Result = OR_No_Viable_Function;
3461 OverloadCandidateSet::iterator Best;
3462 bool AsInitializerList = false;
3464 // C++11 [over.match.list]p1, per DR1467:
3465 // When objects of non-aggregate type T are list-initialized, such that
3466 // 8.5.4 [dcl.init.list] specifies that overload resolution is performed
3467 // according to the rules in this section, overload resolution selects
3468 // the constructor in two phases:
3470 // - Initially, the candidate functions are the initializer-list
3471 // constructors of the class T and the argument list consists of the
3472 // initializer list as a single argument.
3474 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
3475 AsInitializerList = true;
3477 // If the initializer list has no elements and T has a default constructor,
3478 // the first phase is omitted.
3479 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
3480 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3481 CandidateSet, Ctors, Best,
3482 CopyInitialization, AllowExplicit,
3483 /*OnlyListConstructor=*/true,
3486 // Time to unwrap the init list.
3487 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
3490 // C++11 [over.match.list]p1:
3491 // - If no viable initializer-list constructor is found, overload resolution
3492 // is performed again, where the candidate functions are all the
3493 // constructors of the class T and the argument list consists of the
3494 // elements of the initializer list.
3495 if (Result == OR_No_Viable_Function) {
3496 AsInitializerList = false;
3497 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3498 CandidateSet, Ctors, Best,
3499 CopyInitialization, AllowExplicit,
3500 /*OnlyListConstructors=*/false,
3504 Sequence.SetOverloadFailure(IsListInit ?
3505 InitializationSequence::FK_ListConstructorOverloadFailed :
3506 InitializationSequence::FK_ConstructorOverloadFailed,
3511 // C++11 [dcl.init]p6:
3512 // If a program calls for the default initialization of an object
3513 // of a const-qualified type T, T shall be a class type with a
3514 // user-provided default constructor.
3515 if (Kind.getKind() == InitializationKind::IK_Default &&
3516 Entity.getType().isConstQualified() &&
3517 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
3518 if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
3519 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3523 // C++11 [over.match.list]p1:
3524 // In copy-list-initialization, if an explicit constructor is chosen, the
3525 // initializer is ill-formed.
3526 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3527 if (IsListInit && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3528 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3532 // Add the constructor initialization step. Any cv-qualification conversion is
3533 // subsumed by the initialization.
3534 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3535 Sequence.AddConstructorInitializationStep(
3536 CtorDecl, Best->FoundDecl.getAccess(), DestType, HadMultipleCandidates,
3537 IsListInit | IsInitListCopy, AsInitializerList);
3541 ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3543 QualType &SourceType,
3544 QualType &UnqualifiedSourceType,
3545 QualType UnqualifiedTargetType,
3546 InitializationSequence &Sequence) {
3547 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3548 S.Context.OverloadTy) {
3549 DeclAccessPair Found;
3550 bool HadMultipleCandidates = false;
3551 if (FunctionDecl *Fn
3552 = S.ResolveAddressOfOverloadedFunction(Initializer,
3553 UnqualifiedTargetType,
3555 &HadMultipleCandidates)) {
3556 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3557 HadMultipleCandidates);
3558 SourceType = Fn->getType();
3559 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3560 } else if (!UnqualifiedTargetType->isRecordType()) {
3561 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3568 static void TryReferenceInitializationCore(Sema &S,
3569 const InitializedEntity &Entity,
3570 const InitializationKind &Kind,
3572 QualType cv1T1, QualType T1,
3574 QualType cv2T2, QualType T2,
3576 InitializationSequence &Sequence);
3578 static void TryValueInitialization(Sema &S,
3579 const InitializedEntity &Entity,
3580 const InitializationKind &Kind,
3581 InitializationSequence &Sequence,
3582 InitListExpr *InitList = nullptr);
3584 /// \brief Attempt list initialization of a reference.
3585 static void TryReferenceListInitialization(Sema &S,
3586 const InitializedEntity &Entity,
3587 const InitializationKind &Kind,
3588 InitListExpr *InitList,
3589 InitializationSequence &Sequence) {
3590 // First, catch C++03 where this isn't possible.
3591 if (!S.getLangOpts().CPlusPlus11) {
3592 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3595 // Can't reference initialize a compound literal.
3596 if (Entity.getKind() == InitializedEntity::EK_CompoundLiteralInit) {
3597 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3601 QualType DestType = Entity.getType();
3602 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3604 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3606 // Reference initialization via an initializer list works thus:
3607 // If the initializer list consists of a single element that is
3608 // reference-related to the referenced type, bind directly to that element
3609 // (possibly creating temporaries).
3610 // Otherwise, initialize a temporary with the initializer list and
3612 if (InitList->getNumInits() == 1) {
3613 Expr *Initializer = InitList->getInit(0);
3614 QualType cv2T2 = Initializer->getType();
3616 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3618 // If this fails, creating a temporary wouldn't work either.
3619 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3623 SourceLocation DeclLoc = Initializer->getLocStart();
3624 bool dummy1, dummy2, dummy3;
3625 Sema::ReferenceCompareResult RefRelationship
3626 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3628 if (RefRelationship >= Sema::Ref_Related) {
3629 // Try to bind the reference here.
3630 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3631 T1Quals, cv2T2, T2, T2Quals, Sequence);
3633 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3637 // Update the initializer if we've resolved an overloaded function.
3638 if (Sequence.step_begin() != Sequence.step_end())
3639 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3642 // Not reference-related. Create a temporary and bind to that.
3643 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3645 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3647 if (DestType->isRValueReferenceType() ||
3648 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3649 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3652 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3656 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3657 static void TryListInitialization(Sema &S,
3658 const InitializedEntity &Entity,
3659 const InitializationKind &Kind,
3660 InitListExpr *InitList,
3661 InitializationSequence &Sequence) {
3662 QualType DestType = Entity.getType();
3664 // C++ doesn't allow scalar initialization with more than one argument.
3665 // But C99 complex numbers are scalars and it makes sense there.
3666 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3667 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3668 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3671 if (DestType->isReferenceType()) {
3672 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
3676 if (DestType->isRecordType() &&
3677 S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
3678 Sequence.setIncompleteTypeFailure(DestType);
3682 // C++11 [dcl.init.list]p3, per DR1467:
3683 // - If T is a class type and the initializer list has a single element of
3684 // type cv U, where U is T or a class derived from T, the object is
3685 // initialized from that element (by copy-initialization for
3686 // copy-list-initialization, or by direct-initialization for
3687 // direct-list-initialization).
3688 // - Otherwise, if T is a character array and the initializer list has a
3689 // single element that is an appropriately-typed string literal
3690 // (8.5.2 [dcl.init.string]), initialization is performed as described
3692 // - Otherwise, if T is an aggregate, [...] (continue below).
3693 if (S.getLangOpts().CPlusPlus11 && InitList->getNumInits() == 1) {
3694 if (DestType->isRecordType()) {
3695 QualType InitType = InitList->getInit(0)->getType();
3696 if (S.Context.hasSameUnqualifiedType(InitType, DestType) ||
3697 S.IsDerivedFrom(InitType, DestType)) {
3698 Expr *InitAsExpr = InitList->getInit(0);
3699 TryConstructorInitialization(S, Entity, Kind, InitAsExpr, DestType,
3700 Sequence, /*InitListSyntax*/ false,
3701 /*IsInitListCopy*/ true);
3705 if (const ArrayType *DestAT = S.Context.getAsArrayType(DestType)) {
3706 Expr *SubInit[1] = {InitList->getInit(0)};
3707 if (!isa<VariableArrayType>(DestAT) &&
3708 IsStringInit(SubInit[0], DestAT, S.Context) == SIF_None) {
3709 InitializationKind SubKind =
3710 Kind.getKind() == InitializationKind::IK_DirectList
3711 ? InitializationKind::CreateDirect(Kind.getLocation(),
3712 InitList->getLBraceLoc(),
3713 InitList->getRBraceLoc())
3715 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3716 /*TopLevelOfInitList*/ true);
3718 // TryStringLiteralInitialization() (in InitializeFrom()) will fail if
3719 // the element is not an appropriately-typed string literal, in which
3720 // case we should proceed as in C++11 (below).
3722 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3729 // C++11 [dcl.init.list]p3:
3730 // - If T is an aggregate, aggregate initialization is performed.
3731 if (DestType->isRecordType() && !DestType->isAggregateType()) {
3732 if (S.getLangOpts().CPlusPlus11) {
3733 // - Otherwise, if the initializer list has no elements and T is a
3734 // class type with a default constructor, the object is
3735 // value-initialized.
3736 if (InitList->getNumInits() == 0) {
3737 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3738 if (RD->hasDefaultConstructor()) {
3739 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3744 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3745 // an initializer_list object constructed [...]
3746 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3749 // - Otherwise, if T is a class type, constructors are considered.
3750 Expr *InitListAsExpr = InitList;
3751 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3752 Sequence, /*InitListSyntax*/ true);
3754 Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType);
3758 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3759 InitList->getNumInits() == 1 &&
3760 InitList->getInit(0)->getType()->isRecordType()) {
3761 // - Otherwise, if the initializer list has a single element of type E
3762 // [...references are handled above...], the object or reference is
3763 // initialized from that element (by copy-initialization for
3764 // copy-list-initialization, or by direct-initialization for
3765 // direct-list-initialization); if a narrowing conversion is required
3766 // to convert the element to T, the program is ill-formed.
3768 // Per core-24034, this is direct-initialization if we were performing
3769 // direct-list-initialization and copy-initialization otherwise.
3770 // We can't use InitListChecker for this, because it always performs
3771 // copy-initialization. This only matters if we might use an 'explicit'
3772 // conversion operator, so we only need to handle the cases where the source
3773 // is of record type.
3774 InitializationKind SubKind =
3775 Kind.getKind() == InitializationKind::IK_DirectList
3776 ? InitializationKind::CreateDirect(Kind.getLocation(),
3777 InitList->getLBraceLoc(),
3778 InitList->getRBraceLoc())
3780 Expr *SubInit[1] = { InitList->getInit(0) };
3781 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3782 /*TopLevelOfInitList*/true);
3784 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3788 InitListChecker CheckInitList(S, Entity, InitList,
3789 DestType, /*VerifyOnly=*/true);
3790 if (CheckInitList.HadError()) {
3791 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3795 // Add the list initialization step with the built init list.
3796 Sequence.AddListInitializationStep(DestType);
3799 /// \brief Try a reference initialization that involves calling a conversion
3801 static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3802 const InitializedEntity &Entity,
3803 const InitializationKind &Kind,
3806 InitializationSequence &Sequence) {
3807 QualType DestType = Entity.getType();
3808 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3809 QualType T1 = cv1T1.getUnqualifiedType();
3810 QualType cv2T2 = Initializer->getType();
3811 QualType T2 = cv2T2.getUnqualifiedType();
3814 bool ObjCConversion;
3815 bool ObjCLifetimeConversion;
3816 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
3817 T1, T2, DerivedToBase,
3819 ObjCLifetimeConversion) &&
3820 "Must have incompatible references when binding via conversion");
3821 (void)DerivedToBase;
3822 (void)ObjCConversion;
3823 (void)ObjCLifetimeConversion;
3825 // Build the candidate set directly in the initialization sequence
3826 // structure, so that it will persist if we fail.
3827 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3828 CandidateSet.clear();
3830 // Determine whether we are allowed to call explicit constructors or
3831 // explicit conversion operators.
3832 bool AllowExplicit = Kind.AllowExplicit();
3833 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3835 const RecordType *T1RecordType = nullptr;
3836 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3837 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
3838 // The type we're converting to is a class type. Enumerate its constructors
3839 // to see if there is a suitable conversion.
3840 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
3842 for (NamedDecl *D : S.LookupConstructors(T1RecordDecl)) {
3843 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3845 // Find the constructor (which may be a template).
3846 CXXConstructorDecl *Constructor = nullptr;
3847 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3848 if (ConstructorTmpl)
3849 Constructor = cast<CXXConstructorDecl>(
3850 ConstructorTmpl->getTemplatedDecl());
3852 Constructor = cast<CXXConstructorDecl>(D);
3854 if (!Constructor->isInvalidDecl() &&
3855 Constructor->isConvertingConstructor(AllowExplicit)) {
3856 if (ConstructorTmpl)
3857 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3858 /*ExplicitArgs*/ nullptr,
3859 Initializer, CandidateSet,
3860 /*SuppressUserConversions=*/true);
3862 S.AddOverloadCandidate(Constructor, FoundDecl,
3863 Initializer, CandidateSet,
3864 /*SuppressUserConversions=*/true);
3868 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3869 return OR_No_Viable_Function;
3871 const RecordType *T2RecordType = nullptr;
3872 if ((T2RecordType = T2->getAs<RecordType>()) &&
3873 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
3874 // The type we're converting from is a class type, enumerate its conversion
3876 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3878 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
3879 for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3881 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3882 if (isa<UsingShadowDecl>(D))
3883 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3885 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3886 CXXConversionDecl *Conv;
3888 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3890 Conv = cast<CXXConversionDecl>(D);
3892 // If the conversion function doesn't return a reference type,
3893 // it can't be considered for this conversion unless we're allowed to
3894 // consider rvalues.
3895 // FIXME: Do we need to make sure that we only consider conversion
3896 // candidates with reference-compatible results? That might be needed to
3898 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
3899 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3901 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3902 ActingDC, Initializer,
3903 DestType, CandidateSet,
3904 /*AllowObjCConversionOnExplicit=*/
3907 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
3908 Initializer, DestType, CandidateSet,
3909 /*AllowObjCConversionOnExplicit=*/false);
3913 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3914 return OR_No_Viable_Function;
3916 SourceLocation DeclLoc = Initializer->getLocStart();
3918 // Perform overload resolution. If it fails, return the failed result.
3919 OverloadCandidateSet::iterator Best;
3920 if (OverloadingResult Result
3921 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
3924 FunctionDecl *Function = Best->Function;
3925 // This is the overload that will be used for this initialization step if we
3926 // use this initialization. Mark it as referenced.
3927 Function->setReferenced();
3929 // Compute the returned type of the conversion.
3930 if (isa<CXXConversionDecl>(Function))
3931 T2 = Function->getReturnType();
3935 // Add the user-defined conversion step.
3936 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3937 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
3938 T2.getNonLValueExprType(S.Context),
3939 HadMultipleCandidates);
3941 // Determine whether we need to perform derived-to-base or
3942 // cv-qualification adjustments.
3943 ExprValueKind VK = VK_RValue;
3944 if (T2->isLValueReferenceType())
3946 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
3947 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
3949 bool NewDerivedToBase = false;
3950 bool NewObjCConversion = false;
3951 bool NewObjCLifetimeConversion = false;
3952 Sema::ReferenceCompareResult NewRefRelationship
3953 = S.CompareReferenceRelationship(DeclLoc, T1,
3954 T2.getNonLValueExprType(S.Context),
3955 NewDerivedToBase, NewObjCConversion,
3956 NewObjCLifetimeConversion);
3957 if (NewRefRelationship == Sema::Ref_Incompatible) {
3958 // If the type we've converted to is not reference-related to the
3959 // type we're looking for, then there is another conversion step
3960 // we need to perform to produce a temporary of the right type
3961 // that we'll be binding to.
3962 ImplicitConversionSequence ICS;
3964 ICS.Standard = Best->FinalConversion;
3965 T2 = ICS.Standard.getToType(2);
3966 Sequence.AddConversionSequenceStep(ICS, T2);
3967 } else if (NewDerivedToBase)
3968 Sequence.AddDerivedToBaseCastStep(
3969 S.Context.getQualifiedType(T1,
3970 T2.getNonReferenceType().getQualifiers()),
3972 else if (NewObjCConversion)
3973 Sequence.AddObjCObjectConversionStep(
3974 S.Context.getQualifiedType(T1,
3975 T2.getNonReferenceType().getQualifiers()));
3977 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
3978 Sequence.AddQualificationConversionStep(cv1T1, VK);
3980 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3984 static void CheckCXX98CompatAccessibleCopy(Sema &S,
3985 const InitializedEntity &Entity,
3988 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3989 static void TryReferenceInitialization(Sema &S,
3990 const InitializedEntity &Entity,
3991 const InitializationKind &Kind,
3993 InitializationSequence &Sequence) {
3994 QualType DestType = Entity.getType();
3995 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3997 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3998 QualType cv2T2 = Initializer->getType();
4000 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
4002 // If the initializer is the address of an overloaded function, try
4003 // to resolve the overloaded function. If all goes well, T2 is the
4004 // type of the resulting function.
4005 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
4009 // Delegate everything else to a subfunction.
4010 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
4011 T1Quals, cv2T2, T2, T2Quals, Sequence);
4014 /// Converts the target of reference initialization so that it has the
4015 /// appropriate qualifiers and value kind.
4017 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
4020 /// const int &r = x;
4023 /// In this case the reference is binding to a bitfield lvalue, which isn't
4024 /// valid. Perform a load to create a lifetime-extended temporary instead.
4026 /// const int &r = someStruct.bitfield;
4028 static ExprValueKind
4029 convertQualifiersAndValueKindIfNecessary(Sema &S,
4030 InitializationSequence &Sequence,
4036 bool IsNonAddressableType = Initializer->refersToBitField() ||
4037 Initializer->refersToVectorElement();
4039 if (IsNonAddressableType) {
4040 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
4041 // lvalue reference to a non-volatile const type, or the reference shall be
4042 // an rvalue reference.
4044 // If not, we can't make a temporary and bind to that. Give up and allow the
4045 // error to be diagnosed later.
4046 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
4047 assert(Initializer->isGLValue());
4048 return Initializer->getValueKind();
4051 // Force a load so we can materialize a temporary.
4052 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
4056 if (T1Quals != T2Quals) {
4057 Sequence.AddQualificationConversionStep(cv1T1,
4058 Initializer->getValueKind());
4061 return Initializer->getValueKind();
4065 /// \brief Reference initialization without resolving overloaded functions.
4066 static void TryReferenceInitializationCore(Sema &S,
4067 const InitializedEntity &Entity,
4068 const InitializationKind &Kind,
4070 QualType cv1T1, QualType T1,
4072 QualType cv2T2, QualType T2,
4074 InitializationSequence &Sequence) {
4075 QualType DestType = Entity.getType();
4076 SourceLocation DeclLoc = Initializer->getLocStart();
4077 // Compute some basic properties of the types and the initializer.
4078 bool isLValueRef = DestType->isLValueReferenceType();
4079 bool isRValueRef = !isLValueRef;
4080 bool DerivedToBase = false;
4081 bool ObjCConversion = false;
4082 bool ObjCLifetimeConversion = false;
4083 Expr::Classification InitCategory = Initializer->Classify(S.Context);
4084 Sema::ReferenceCompareResult RefRelationship
4085 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
4086 ObjCConversion, ObjCLifetimeConversion);
4088 // C++0x [dcl.init.ref]p5:
4089 // A reference to type "cv1 T1" is initialized by an expression of type
4090 // "cv2 T2" as follows:
4092 // - If the reference is an lvalue reference and the initializer
4094 // Note the analogous bullet points for rvalue refs to functions. Because
4095 // there are no function rvalues in C++, rvalue refs to functions are treated
4096 // like lvalue refs.
4097 OverloadingResult ConvOvlResult = OR_Success;
4098 bool T1Function = T1->isFunctionType();
4099 if (isLValueRef || T1Function) {
4100 if (InitCategory.isLValue() &&
4101 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4102 (Kind.isCStyleOrFunctionalCast() &&
4103 RefRelationship == Sema::Ref_Related))) {
4104 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
4105 // reference-compatible with "cv2 T2," or
4107 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
4108 // bit-field when we're determining whether the reference initialization
4109 // can occur. However, we do pay attention to whether it is a bit-field
4110 // to decide whether we're actually binding to a temporary created from
4113 Sequence.AddDerivedToBaseCastStep(
4114 S.Context.getQualifiedType(T1, T2Quals),
4116 else if (ObjCConversion)
4117 Sequence.AddObjCObjectConversionStep(
4118 S.Context.getQualifiedType(T1, T2Quals));
4120 ExprValueKind ValueKind =
4121 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
4122 cv1T1, T1Quals, T2Quals,
4124 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4128 // - has a class type (i.e., T2 is a class type), where T1 is not
4129 // reference-related to T2, and can be implicitly converted to an
4130 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
4131 // with "cv3 T3" (this conversion is selected by enumerating the
4132 // applicable conversion functions (13.3.1.6) and choosing the best
4133 // one through overload resolution (13.3)),
4134 // If we have an rvalue ref to function type here, the rhs must be
4135 // an rvalue. DR1287 removed the "implicitly" here.
4136 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
4137 (isLValueRef || InitCategory.isRValue())) {
4138 ConvOvlResult = TryRefInitWithConversionFunction(
4139 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
4140 if (ConvOvlResult == OR_Success)
4142 if (ConvOvlResult != OR_No_Viable_Function)
4143 Sequence.SetOverloadFailure(
4144 InitializationSequence::FK_ReferenceInitOverloadFailed,
4149 // - Otherwise, the reference shall be an lvalue reference to a
4150 // non-volatile const type (i.e., cv1 shall be const), or the reference
4151 // shall be an rvalue reference.
4152 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
4153 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4154 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4155 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4156 Sequence.SetOverloadFailure(
4157 InitializationSequence::FK_ReferenceInitOverloadFailed,
4160 Sequence.SetFailed(InitCategory.isLValue()
4161 ? (RefRelationship == Sema::Ref_Related
4162 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
4163 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
4164 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
4169 // - If the initializer expression
4170 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
4171 // "cv1 T1" is reference-compatible with "cv2 T2"
4172 // Note: functions are handled below.
4174 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
4175 (Kind.isCStyleOrFunctionalCast() &&
4176 RefRelationship == Sema::Ref_Related)) &&
4177 (InitCategory.isXValue() ||
4178 (InitCategory.isPRValue() && T2->isRecordType()) ||
4179 (InitCategory.isPRValue() && T2->isArrayType()))) {
4180 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
4181 if (InitCategory.isPRValue() && T2->isRecordType()) {
4182 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
4183 // compiler the freedom to perform a copy here or bind to the
4184 // object, while C++0x requires that we bind directly to the
4185 // object. Hence, we always bind to the object without making an
4186 // extra copy. However, in C++03 requires that we check for the
4187 // presence of a suitable copy constructor:
4189 // The constructor that would be used to make the copy shall
4190 // be callable whether or not the copy is actually done.
4191 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
4192 Sequence.AddExtraneousCopyToTemporary(cv2T2);
4193 else if (S.getLangOpts().CPlusPlus11)
4194 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
4198 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
4200 else if (ObjCConversion)
4201 Sequence.AddObjCObjectConversionStep(
4202 S.Context.getQualifiedType(T1, T2Quals));
4204 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
4209 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
4213 // - has a class type (i.e., T2 is a class type), where T1 is not
4214 // reference-related to T2, and can be implicitly converted to an
4215 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
4216 // where "cv1 T1" is reference-compatible with "cv3 T3",
4218 // DR1287 removes the "implicitly" here.
4219 if (T2->isRecordType()) {
4220 if (RefRelationship == Sema::Ref_Incompatible) {
4221 ConvOvlResult = TryRefInitWithConversionFunction(
4222 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
4224 Sequence.SetOverloadFailure(
4225 InitializationSequence::FK_ReferenceInitOverloadFailed,
4231 if ((RefRelationship == Sema::Ref_Compatible ||
4232 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
4233 isRValueRef && InitCategory.isLValue()) {
4235 InitializationSequence::FK_RValueReferenceBindingToLValue);
4239 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4243 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
4244 // from the initializer expression using the rules for a non-reference
4245 // copy-initialization (8.5). The reference is then bound to the
4248 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
4250 // FIXME: Why do we use an implicit conversion here rather than trying
4251 // copy-initialization?
4252 ImplicitConversionSequence ICS
4253 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
4254 /*SuppressUserConversions=*/false,
4255 /*AllowExplicit=*/false,
4256 /*FIXME:InOverloadResolution=*/false,
4257 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4258 /*AllowObjCWritebackConversion=*/false);
4261 // FIXME: Use the conversion function set stored in ICS to turn
4262 // this into an overloading ambiguity diagnostic. However, we need
4263 // to keep that set as an OverloadCandidateSet rather than as some
4264 // other kind of set.
4265 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
4266 Sequence.SetOverloadFailure(
4267 InitializationSequence::FK_ReferenceInitOverloadFailed,
4269 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
4270 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4272 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
4275 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
4278 // [...] If T1 is reference-related to T2, cv1 must be the
4279 // same cv-qualification as, or greater cv-qualification
4280 // than, cv2; otherwise, the program is ill-formed.
4281 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
4282 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
4283 if (RefRelationship == Sema::Ref_Related &&
4284 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
4285 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
4289 // [...] If T1 is reference-related to T2 and the reference is an rvalue
4290 // reference, the initializer expression shall not be an lvalue.
4291 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
4292 InitCategory.isLValue()) {
4294 InitializationSequence::FK_RValueReferenceBindingToLValue);
4298 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
4302 /// \brief Attempt character array initialization from a string literal
4303 /// (C++ [dcl.init.string], C99 6.7.8).
4304 static void TryStringLiteralInitialization(Sema &S,
4305 const InitializedEntity &Entity,
4306 const InitializationKind &Kind,
4308 InitializationSequence &Sequence) {
4309 Sequence.AddStringInitStep(Entity.getType());
4312 /// \brief Attempt value initialization (C++ [dcl.init]p7).
4313 static void TryValueInitialization(Sema &S,
4314 const InitializedEntity &Entity,
4315 const InitializationKind &Kind,
4316 InitializationSequence &Sequence,
4317 InitListExpr *InitList) {
4318 assert((!InitList || InitList->getNumInits() == 0) &&
4319 "Shouldn't use value-init for non-empty init lists");
4321 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
4323 // To value-initialize an object of type T means:
4324 QualType T = Entity.getType();
4326 // -- if T is an array type, then each element is value-initialized;
4327 T = S.Context.getBaseElementType(T);
4329 if (const RecordType *RT = T->getAs<RecordType>()) {
4330 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4331 bool NeedZeroInitialization = true;
4332 if (!S.getLangOpts().CPlusPlus11) {
4334 // -- if T is a class type (clause 9) with a user-declared constructor
4335 // (12.1), then the default constructor for T is called (and the
4336 // initialization is ill-formed if T has no accessible default
4338 if (ClassDecl->hasUserDeclaredConstructor())
4339 NeedZeroInitialization = false;
4342 // -- if T is a class type (clause 9) with either no default constructor
4343 // (12.1 [class.ctor]) or a default constructor that is user-provided
4344 // or deleted, then the object is default-initialized;
4345 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
4346 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
4347 NeedZeroInitialization = false;
4350 // -- if T is a (possibly cv-qualified) non-union class type without a
4351 // user-provided or deleted default constructor, then the object is
4352 // zero-initialized and, if T has a non-trivial default constructor,
4353 // default-initialized;
4354 // The 'non-union' here was removed by DR1502. The 'non-trivial default
4355 // constructor' part was removed by DR1507.
4356 if (NeedZeroInitialization)
4357 Sequence.AddZeroInitializationStep(Entity.getType());
4360 // -- if T is a non-union class type without a user-declared constructor,
4361 // then every non-static data member and base class component of T is
4362 // value-initialized;
4363 // [...] A program that calls for [...] value-initialization of an
4364 // entity of reference type is ill-formed.
4366 // C++11 doesn't need this handling, because value-initialization does not
4367 // occur recursively there, and the implicit default constructor is
4368 // defined as deleted in the problematic cases.
4369 if (!S.getLangOpts().CPlusPlus11 &&
4370 ClassDecl->hasUninitializedReferenceMember()) {
4371 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
4375 // If this is list-value-initialization, pass the empty init list on when
4376 // building the constructor call. This affects the semantics of a few
4377 // things (such as whether an explicit default constructor can be called).
4378 Expr *InitListAsExpr = InitList;
4379 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
4380 bool InitListSyntax = InitList;
4382 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
4387 Sequence.AddZeroInitializationStep(Entity.getType());
4390 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4391 static void TryDefaultInitialization(Sema &S,
4392 const InitializedEntity &Entity,
4393 const InitializationKind &Kind,
4394 InitializationSequence &Sequence) {
4395 assert(Kind.getKind() == InitializationKind::IK_Default);
4397 // C++ [dcl.init]p6:
4398 // To default-initialize an object of type T means:
4399 // - if T is an array type, each element is default-initialized;
4400 QualType DestType = S.Context.getBaseElementType(Entity.getType());
4402 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4403 // constructor for T is called (and the initialization is ill-formed if
4404 // T has no accessible default constructor);
4405 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4406 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
4410 // - otherwise, no initialization is performed.
4412 // If a program calls for the default initialization of an object of
4413 // a const-qualified type T, T shall be a class type with a user-provided
4414 // default constructor.
4415 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4416 if (!maybeRecoverWithZeroInitialization(S, Sequence, Entity))
4417 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
4421 // If the destination type has a lifetime property, zero-initialize it.
4422 if (DestType.getQualifiers().hasObjCLifetime()) {
4423 Sequence.AddZeroInitializationStep(Entity.getType());
4428 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4429 /// which enumerates all conversion functions and performs overload resolution
4430 /// to select the best.
4431 static void TryUserDefinedConversion(Sema &S,
4433 const InitializationKind &Kind,
4435 InitializationSequence &Sequence,
4436 bool TopLevelOfInitList) {
4437 assert(!DestType->isReferenceType() && "References are handled elsewhere");
4438 QualType SourceType = Initializer->getType();
4439 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4440 "Must have a class type to perform a user-defined conversion");
4442 // Build the candidate set directly in the initialization sequence
4443 // structure, so that it will persist if we fail.
4444 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4445 CandidateSet.clear();
4447 // Determine whether we are allowed to call explicit constructors or
4448 // explicit conversion operators.
4449 bool AllowExplicit = Kind.AllowExplicit();
4451 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4452 // The type we're converting to is a class type. Enumerate its constructors
4453 // to see if there is a suitable conversion.
4454 CXXRecordDecl *DestRecordDecl
4455 = cast<CXXRecordDecl>(DestRecordType->getDecl());
4457 // Try to complete the type we're converting to.
4458 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
4459 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4460 // The container holding the constructors can under certain conditions
4461 // be changed while iterating. To be safe we copy the lookup results
4462 // to a new container.
4463 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4464 for (SmallVectorImpl<NamedDecl *>::iterator
4465 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4466 Con != ConEnd; ++Con) {
4467 NamedDecl *D = *Con;
4468 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
4470 // Find the constructor (which may be a template).
4471 CXXConstructorDecl *Constructor = nullptr;
4472 FunctionTemplateDecl *ConstructorTmpl
4473 = dyn_cast<FunctionTemplateDecl>(D);
4474 if (ConstructorTmpl)
4475 Constructor = cast<CXXConstructorDecl>(
4476 ConstructorTmpl->getTemplatedDecl());
4478 Constructor = cast<CXXConstructorDecl>(D);
4480 if (!Constructor->isInvalidDecl() &&
4481 Constructor->isConvertingConstructor(AllowExplicit)) {
4482 if (ConstructorTmpl)
4483 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4484 /*ExplicitArgs*/ nullptr,
4485 Initializer, CandidateSet,
4486 /*SuppressUserConversions=*/true);
4488 S.AddOverloadCandidate(Constructor, FoundDecl,
4489 Initializer, CandidateSet,
4490 /*SuppressUserConversions=*/true);
4496 SourceLocation DeclLoc = Initializer->getLocStart();
4498 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4499 // The type we're converting from is a class type, enumerate its conversion
4502 // We can only enumerate the conversion functions for a complete type; if
4503 // the type isn't complete, simply skip this step.
4504 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4505 CXXRecordDecl *SourceRecordDecl
4506 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4508 const auto &Conversions =
4509 SourceRecordDecl->getVisibleConversionFunctions();
4510 for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4512 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4513 if (isa<UsingShadowDecl>(D))
4514 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4516 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4517 CXXConversionDecl *Conv;
4519 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4521 Conv = cast<CXXConversionDecl>(D);
4523 if (AllowExplicit || !Conv->isExplicit()) {
4525 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4526 ActingDC, Initializer, DestType,
4527 CandidateSet, AllowExplicit);
4529 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4530 Initializer, DestType, CandidateSet,
4537 // Perform overload resolution. If it fails, return the failed result.
4538 OverloadCandidateSet::iterator Best;
4539 if (OverloadingResult Result
4540 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4541 Sequence.SetOverloadFailure(
4542 InitializationSequence::FK_UserConversionOverloadFailed,
4547 FunctionDecl *Function = Best->Function;
4548 Function->setReferenced();
4549 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4551 if (isa<CXXConstructorDecl>(Function)) {
4552 // Add the user-defined conversion step. Any cv-qualification conversion is
4553 // subsumed by the initialization. Per DR5, the created temporary is of the
4554 // cv-unqualified type of the destination.
4555 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4556 DestType.getUnqualifiedType(),
4557 HadMultipleCandidates);
4561 // Add the user-defined conversion step that calls the conversion function.
4562 QualType ConvType = Function->getCallResultType();
4563 if (ConvType->getAs<RecordType>()) {
4564 // If we're converting to a class type, there may be an copy of
4565 // the resulting temporary object (possible to create an object of
4566 // a base class type). That copy is not a separate conversion, so
4567 // we just make a note of the actual destination type (possibly a
4568 // base class of the type returned by the conversion function) and
4569 // let the user-defined conversion step handle the conversion.
4570 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4571 HadMultipleCandidates);
4575 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4576 HadMultipleCandidates);
4578 // If the conversion following the call to the conversion function
4579 // is interesting, add it as a separate step.
4580 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4581 Best->FinalConversion.Third) {
4582 ImplicitConversionSequence ICS;
4584 ICS.Standard = Best->FinalConversion;
4585 Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4589 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4590 /// a function with a pointer return type contains a 'return false;' statement.
4591 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4592 /// code using that header.
4594 /// Work around this by treating 'return false;' as zero-initializing the result
4595 /// if it's used in a pointer-returning function in a system header.
4596 static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4597 const InitializedEntity &Entity,
4599 return S.getLangOpts().CPlusPlus11 &&
4600 Entity.getKind() == InitializedEntity::EK_Result &&
4601 Entity.getType()->isPointerType() &&
4602 isa<CXXBoolLiteralExpr>(Init) &&
4603 !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4604 S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4607 /// The non-zero enum values here are indexes into diagnostic alternatives.
4608 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4610 /// Determines whether this expression is an acceptable ICR source.
4611 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
4612 bool isAddressOf, bool &isWeakAccess) {
4614 e = e->IgnoreParens();
4616 // Skip address-of nodes.
4617 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4618 if (op->getOpcode() == UO_AddrOf)
4619 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4622 // Skip certain casts.
4623 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4624 switch (ce->getCastKind()) {
4627 case CK_LValueBitCast:
4629 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4631 case CK_ArrayToPointerDecay:
4632 return IIK_nonscalar;
4634 case CK_NullToPointer:
4641 // If we have a declaration reference, it had better be a local variable.
4642 } else if (isa<DeclRefExpr>(e)) {
4643 // set isWeakAccess to true, to mean that there will be an implicit
4644 // load which requires a cleanup.
4645 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4646 isWeakAccess = true;
4648 if (!isAddressOf) return IIK_nonlocal;
4650 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4651 if (!var) return IIK_nonlocal;
4653 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4655 // If we have a conditional operator, check both sides.
4656 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4657 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4661 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4663 // These are never scalar.
4664 } else if (isa<ArraySubscriptExpr>(e)) {
4665 return IIK_nonscalar;
4667 // Otherwise, it needs to be a null pointer constant.
4669 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4670 ? IIK_okay : IIK_nonlocal);
4673 return IIK_nonlocal;
4676 /// Check whether the given expression is a valid operand for an
4677 /// indirect copy/restore.
4678 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4679 assert(src->isRValue());
4680 bool isWeakAccess = false;
4681 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4682 // If isWeakAccess to true, there will be an implicit
4683 // load which requires a cleanup.
4684 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4685 S.ExprNeedsCleanups = true;
4687 if (iik == IIK_okay) return;
4689 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4690 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4691 << src->getSourceRange();
4694 /// \brief Determine whether we have compatible array types for the
4695 /// purposes of GNU by-copy array initialization.
4696 static bool hasCompatibleArrayTypes(ASTContext &Context, const ArrayType *Dest,
4697 const ArrayType *Source) {
4698 // If the source and destination array types are equivalent, we're
4700 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4703 // Make sure that the element types are the same.
4704 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4707 // The only mismatch we allow is when the destination is an
4708 // incomplete array type and the source is a constant array type.
4709 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4712 static bool tryObjCWritebackConversion(Sema &S,
4713 InitializationSequence &Sequence,
4714 const InitializedEntity &Entity,
4715 Expr *Initializer) {
4716 bool ArrayDecay = false;
4717 QualType ArgType = Initializer->getType();
4718 QualType ArgPointee;
4719 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4721 ArgPointee = ArgArrayType->getElementType();
4722 ArgType = S.Context.getPointerType(ArgPointee);
4725 // Handle write-back conversion.
4726 QualType ConvertedArgType;
4727 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4731 // We should copy unless we're passing to an argument explicitly
4733 bool ShouldCopy = true;
4734 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4735 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4737 // Do we need an lvalue conversion?
4738 if (ArrayDecay || Initializer->isGLValue()) {
4739 ImplicitConversionSequence ICS;
4741 ICS.Standard.setAsIdentityConversion();
4743 QualType ResultType;
4745 ICS.Standard.First = ICK_Array_To_Pointer;
4746 ResultType = S.Context.getPointerType(ArgPointee);
4748 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4749 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4752 Sequence.AddConversionSequenceStep(ICS, ResultType);
4755 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4759 static bool TryOCLSamplerInitialization(Sema &S,
4760 InitializationSequence &Sequence,
4762 Expr *Initializer) {
4763 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4764 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4767 Sequence.AddOCLSamplerInitStep(DestType);
4772 // OpenCL 1.2 spec, s6.12.10
4774 // The event argument can also be used to associate the
4775 // async_work_group_copy with a previous async copy allowing
4776 // an event to be shared by multiple async copies; otherwise
4777 // event should be zero.
4779 static bool TryOCLZeroEventInitialization(Sema &S,
4780 InitializationSequence &Sequence,
4782 Expr *Initializer) {
4783 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4784 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4785 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4788 Sequence.AddOCLZeroEventStep(DestType);
4792 InitializationSequence::InitializationSequence(Sema &S,
4793 const InitializedEntity &Entity,
4794 const InitializationKind &Kind,
4796 bool TopLevelOfInitList)
4797 : FailedCandidateSet(Kind.getLocation(), OverloadCandidateSet::CSK_Normal) {
4798 InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4801 void InitializationSequence::InitializeFrom(Sema &S,
4802 const InitializedEntity &Entity,
4803 const InitializationKind &Kind,
4805 bool TopLevelOfInitList) {
4806 ASTContext &Context = S.Context;
4808 // Eliminate non-overload placeholder types in the arguments. We
4809 // need to do this before checking whether types are dependent
4810 // because lowering a pseudo-object expression might well give us
4811 // something of dependent type.
4812 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4813 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4814 // FIXME: should we be doing this here?
4815 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4816 if (result.isInvalid()) {
4817 SetFailed(FK_PlaceholderType);
4820 Args[I] = result.get();
4823 // C++0x [dcl.init]p16:
4824 // The semantics of initializers are as follows. The destination type is
4825 // the type of the object or reference being initialized and the source
4826 // type is the type of the initializer expression. The source type is not
4827 // defined when the initializer is a braced-init-list or when it is a
4828 // parenthesized list of expressions.
4829 QualType DestType = Entity.getType();
4831 if (DestType->isDependentType() ||
4832 Expr::hasAnyTypeDependentArguments(Args)) {
4833 SequenceKind = DependentSequence;
4837 // Almost everything is a normal sequence.
4838 setSequenceKind(NormalSequence);
4840 QualType SourceType;
4841 Expr *Initializer = nullptr;
4842 if (Args.size() == 1) {
4843 Initializer = Args[0];
4844 if (S.getLangOpts().ObjC1) {
4845 if (S.CheckObjCBridgeRelatedConversions(Initializer->getLocStart(),
4846 DestType, Initializer->getType(),
4848 S.ConversionToObjCStringLiteralCheck(DestType, Initializer))
4849 Args[0] = Initializer;
4851 if (!isa<InitListExpr>(Initializer))
4852 SourceType = Initializer->getType();
4855 // - If the initializer is a (non-parenthesized) braced-init-list, the
4856 // object is list-initialized (8.5.4).
4857 if (Kind.getKind() != InitializationKind::IK_Direct) {
4858 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4859 TryListInitialization(S, Entity, Kind, InitList, *this);
4864 // - If the destination type is a reference type, see 8.5.3.
4865 if (DestType->isReferenceType()) {
4866 // C++0x [dcl.init.ref]p1:
4867 // A variable declared to be a T& or T&&, that is, "reference to type T"
4868 // (8.3.2), shall be initialized by an object, or function, of type T or
4869 // by an object that can be converted into a T.
4870 // (Therefore, multiple arguments are not permitted.)
4871 if (Args.size() != 1)
4872 SetFailed(FK_TooManyInitsForReference);
4874 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
4878 // - If the initializer is (), the object is value-initialized.
4879 if (Kind.getKind() == InitializationKind::IK_Value ||
4880 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
4881 TryValueInitialization(S, Entity, Kind, *this);
4885 // Handle default initialization.
4886 if (Kind.getKind() == InitializationKind::IK_Default) {
4887 TryDefaultInitialization(S, Entity, Kind, *this);
4891 // - If the destination type is an array of characters, an array of
4892 // char16_t, an array of char32_t, or an array of wchar_t, and the
4893 // initializer is a string literal, see 8.5.2.
4894 // - Otherwise, if the destination type is an array, the program is
4896 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
4897 if (Initializer && isa<VariableArrayType>(DestAT)) {
4898 SetFailed(FK_VariableLengthArrayHasInitializer);
4903 switch (IsStringInit(Initializer, DestAT, Context)) {
4905 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4907 case SIF_NarrowStringIntoWideChar:
4908 SetFailed(FK_NarrowStringIntoWideCharArray);
4910 case SIF_WideStringIntoChar:
4911 SetFailed(FK_WideStringIntoCharArray);
4913 case SIF_IncompatWideStringIntoWideChar:
4914 SetFailed(FK_IncompatWideStringIntoWideChar);
4921 // Note: as an GNU C extension, we allow initialization of an
4922 // array from a compound literal that creates an array of the same
4923 // type, so long as the initializer has no side effects.
4924 if (!S.getLangOpts().CPlusPlus && Initializer &&
4925 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4926 Initializer->getType()->isArrayType()) {
4927 const ArrayType *SourceAT
4928 = Context.getAsArrayType(Initializer->getType());
4929 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
4930 SetFailed(FK_ArrayTypeMismatch);
4931 else if (Initializer->HasSideEffects(S.Context))
4932 SetFailed(FK_NonConstantArrayInit);
4934 AddArrayInitStep(DestType);
4937 // Note: as a GNU C++ extension, we allow list-initialization of a
4938 // class member of array type from a parenthesized initializer list.
4939 else if (S.getLangOpts().CPlusPlus &&
4940 Entity.getKind() == InitializedEntity::EK_Member &&
4941 Initializer && isa<InitListExpr>(Initializer)) {
4942 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4944 AddParenthesizedArrayInitStep(DestType);
4945 } else if (DestAT->getElementType()->isCharType())
4946 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
4947 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4948 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
4950 SetFailed(FK_ArrayNeedsInitList);
4955 // Determine whether we should consider writeback conversions for
4957 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
4958 Entity.isParameterKind();
4960 // We're at the end of the line for C: it's either a write-back conversion
4961 // or it's a C assignment. There's no need to check anything else.
4962 if (!S.getLangOpts().CPlusPlus) {
4963 // If allowed, check whether this is an Objective-C writeback conversion.
4964 if (allowObjCWritebackConversion &&
4965 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
4969 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4972 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4975 // Handle initialization in C
4976 AddCAssignmentStep(DestType);
4977 MaybeProduceObjCObject(S, *this, Entity);
4981 assert(S.getLangOpts().CPlusPlus);
4983 // - If the destination type is a (possibly cv-qualified) class type:
4984 if (DestType->isRecordType()) {
4985 // - If the initialization is direct-initialization, or if it is
4986 // copy-initialization where the cv-unqualified version of the
4987 // source type is the same class as, or a derived class of, the
4988 // class of the destination, constructors are considered. [...]
4989 if (Kind.getKind() == InitializationKind::IK_Direct ||
4990 (Kind.getKind() == InitializationKind::IK_Copy &&
4991 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4992 S.IsDerivedFrom(SourceType, DestType))))
4993 TryConstructorInitialization(S, Entity, Kind, Args,
4995 // - Otherwise (i.e., for the remaining copy-initialization cases),
4996 // user-defined conversion sequences that can convert from the source
4997 // type to the destination type or (when a conversion function is
4998 // used) to a derived class thereof are enumerated as described in
4999 // 13.3.1.4, and the best one is chosen through overload resolution
5002 TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5003 TopLevelOfInitList);
5007 if (Args.size() > 1) {
5008 SetFailed(FK_TooManyInitsForScalar);
5011 assert(Args.size() == 1 && "Zero-argument case handled above");
5013 // - Otherwise, if the source type is a (possibly cv-qualified) class
5014 // type, conversion functions are considered.
5015 if (!SourceType.isNull() && SourceType->isRecordType()) {
5016 // For a conversion to _Atomic(T) from either T or a class type derived
5017 // from T, initialize the T object then convert to _Atomic type.
5018 bool NeedAtomicConversion = false;
5019 if (const AtomicType *Atomic = DestType->getAs<AtomicType>()) {
5020 if (Context.hasSameUnqualifiedType(SourceType, Atomic->getValueType()) ||
5021 S.IsDerivedFrom(SourceType, Atomic->getValueType())) {
5022 DestType = Atomic->getValueType();
5023 NeedAtomicConversion = true;
5027 TryUserDefinedConversion(S, DestType, Kind, Initializer, *this,
5028 TopLevelOfInitList);
5029 MaybeProduceObjCObject(S, *this, Entity);
5030 if (!Failed() && NeedAtomicConversion)
5031 AddAtomicConversionStep(Entity.getType());
5035 // - Otherwise, the initial value of the object being initialized is the
5036 // (possibly converted) value of the initializer expression. Standard
5037 // conversions (Clause 4) will be used, if necessary, to convert the
5038 // initializer expression to the cv-unqualified version of the
5039 // destination type; no user-defined conversions are considered.
5041 ImplicitConversionSequence ICS
5042 = S.TryImplicitConversion(Initializer, DestType,
5043 /*SuppressUserConversions*/true,
5044 /*AllowExplicitConversions*/ false,
5045 /*InOverloadResolution*/ false,
5046 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
5047 allowObjCWritebackConversion);
5049 if (ICS.isStandard() &&
5050 ICS.Standard.Second == ICK_Writeback_Conversion) {
5051 // Objective-C ARC writeback conversion.
5053 // We should copy unless we're passing to an argument explicitly
5055 bool ShouldCopy = true;
5056 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
5057 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
5059 // If there was an lvalue adjustment, add it as a separate conversion.
5060 if (ICS.Standard.First == ICK_Array_To_Pointer ||
5061 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
5062 ImplicitConversionSequence LvalueICS;
5063 LvalueICS.setStandard();
5064 LvalueICS.Standard.setAsIdentityConversion();
5065 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
5066 LvalueICS.Standard.First = ICS.Standard.First;
5067 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
5070 AddPassByIndirectCopyRestoreStep(DestType, ShouldCopy);
5071 } else if (ICS.isBad()) {
5073 if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
5074 AddZeroInitializationStep(Entity.getType());
5075 } else if (Initializer->getType() == Context.OverloadTy &&
5076 !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
5078 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
5080 SetFailed(InitializationSequence::FK_ConversionFailed);
5082 AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
5084 MaybeProduceObjCObject(S, *this, Entity);
5088 InitializationSequence::~InitializationSequence() {
5089 for (auto &S : Steps)
5093 //===----------------------------------------------------------------------===//
5094 // Perform initialization
5095 //===----------------------------------------------------------------------===//
5096 static Sema::AssignmentAction
5097 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
5098 switch(Entity.getKind()) {
5099 case InitializedEntity::EK_Variable:
5100 case InitializedEntity::EK_New:
5101 case InitializedEntity::EK_Exception:
5102 case InitializedEntity::EK_Base:
5103 case InitializedEntity::EK_Delegating:
5104 return Sema::AA_Initializing;
5106 case InitializedEntity::EK_Parameter:
5107 if (Entity.getDecl() &&
5108 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5109 return Sema::AA_Sending;
5111 return Sema::AA_Passing;
5113 case InitializedEntity::EK_Parameter_CF_Audited:
5114 if (Entity.getDecl() &&
5115 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
5116 return Sema::AA_Sending;
5118 return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
5120 case InitializedEntity::EK_Result:
5121 return Sema::AA_Returning;
5123 case InitializedEntity::EK_Temporary:
5124 case InitializedEntity::EK_RelatedResult:
5125 // FIXME: Can we tell apart casting vs. converting?
5126 return Sema::AA_Casting;
5128 case InitializedEntity::EK_Member:
5129 case InitializedEntity::EK_ArrayElement:
5130 case InitializedEntity::EK_VectorElement:
5131 case InitializedEntity::EK_ComplexElement:
5132 case InitializedEntity::EK_BlockElement:
5133 case InitializedEntity::EK_LambdaCapture:
5134 case InitializedEntity::EK_CompoundLiteralInit:
5135 return Sema::AA_Initializing;
5138 llvm_unreachable("Invalid EntityKind!");
5141 /// \brief Whether we should bind a created object as a temporary when
5142 /// initializing the given entity.
5143 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
5144 switch (Entity.getKind()) {
5145 case InitializedEntity::EK_ArrayElement:
5146 case InitializedEntity::EK_Member:
5147 case InitializedEntity::EK_Result:
5148 case InitializedEntity::EK_New:
5149 case InitializedEntity::EK_Variable:
5150 case InitializedEntity::EK_Base:
5151 case InitializedEntity::EK_Delegating:
5152 case InitializedEntity::EK_VectorElement:
5153 case InitializedEntity::EK_ComplexElement:
5154 case InitializedEntity::EK_Exception:
5155 case InitializedEntity::EK_BlockElement:
5156 case InitializedEntity::EK_LambdaCapture:
5157 case InitializedEntity::EK_CompoundLiteralInit:
5160 case InitializedEntity::EK_Parameter:
5161 case InitializedEntity::EK_Parameter_CF_Audited:
5162 case InitializedEntity::EK_Temporary:
5163 case InitializedEntity::EK_RelatedResult:
5167 llvm_unreachable("missed an InitializedEntity kind?");
5170 /// \brief Whether the given entity, when initialized with an object
5171 /// created for that initialization, requires destruction.
5172 static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
5173 switch (Entity.getKind()) {
5174 case InitializedEntity::EK_Result:
5175 case InitializedEntity::EK_New:
5176 case InitializedEntity::EK_Base:
5177 case InitializedEntity::EK_Delegating:
5178 case InitializedEntity::EK_VectorElement:
5179 case InitializedEntity::EK_ComplexElement:
5180 case InitializedEntity::EK_BlockElement:
5181 case InitializedEntity::EK_LambdaCapture:
5184 case InitializedEntity::EK_Member:
5185 case InitializedEntity::EK_Variable:
5186 case InitializedEntity::EK_Parameter:
5187 case InitializedEntity::EK_Parameter_CF_Audited:
5188 case InitializedEntity::EK_Temporary:
5189 case InitializedEntity::EK_ArrayElement:
5190 case InitializedEntity::EK_Exception:
5191 case InitializedEntity::EK_CompoundLiteralInit:
5192 case InitializedEntity::EK_RelatedResult:
5196 llvm_unreachable("missed an InitializedEntity kind?");
5199 /// \brief Look for copy and move constructors and constructor templates, for
5200 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
5201 static void LookupCopyAndMoveConstructors(Sema &S,
5202 OverloadCandidateSet &CandidateSet,
5203 CXXRecordDecl *Class,
5204 Expr *CurInitExpr) {
5205 DeclContext::lookup_result R = S.LookupConstructors(Class);
5206 // The container holding the constructors can under certain conditions
5207 // be changed while iterating (e.g. because of deserialization).
5208 // To be safe we copy the lookup results to a new container.
5209 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
5210 for (SmallVectorImpl<NamedDecl *>::iterator
5211 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
5213 CXXConstructorDecl *Constructor = nullptr;
5215 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
5216 // Handle copy/moveconstructors, only.
5217 if (!Constructor || Constructor->isInvalidDecl() ||
5218 !Constructor->isCopyOrMoveConstructor() ||
5219 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
5222 DeclAccessPair FoundDecl
5223 = DeclAccessPair::make(Constructor, Constructor->getAccess());
5224 S.AddOverloadCandidate(Constructor, FoundDecl,
5225 CurInitExpr, CandidateSet);
5229 // Handle constructor templates.
5230 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
5231 if (ConstructorTmpl->isInvalidDecl())
5234 Constructor = cast<CXXConstructorDecl>(
5235 ConstructorTmpl->getTemplatedDecl());
5236 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
5239 // FIXME: Do we need to limit this to copy-constructor-like
5241 DeclAccessPair FoundDecl
5242 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
5243 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, nullptr,
5244 CurInitExpr, CandidateSet, true);
5248 /// \brief Get the location at which initialization diagnostics should appear.
5249 static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
5250 Expr *Initializer) {
5251 switch (Entity.getKind()) {
5252 case InitializedEntity::EK_Result:
5253 return Entity.getReturnLoc();
5255 case InitializedEntity::EK_Exception:
5256 return Entity.getThrowLoc();
5258 case InitializedEntity::EK_Variable:
5259 return Entity.getDecl()->getLocation();
5261 case InitializedEntity::EK_LambdaCapture:
5262 return Entity.getCaptureLoc();
5264 case InitializedEntity::EK_ArrayElement:
5265 case InitializedEntity::EK_Member:
5266 case InitializedEntity::EK_Parameter:
5267 case InitializedEntity::EK_Parameter_CF_Audited:
5268 case InitializedEntity::EK_Temporary:
5269 case InitializedEntity::EK_New:
5270 case InitializedEntity::EK_Base:
5271 case InitializedEntity::EK_Delegating:
5272 case InitializedEntity::EK_VectorElement:
5273 case InitializedEntity::EK_ComplexElement:
5274 case InitializedEntity::EK_BlockElement:
5275 case InitializedEntity::EK_CompoundLiteralInit:
5276 case InitializedEntity::EK_RelatedResult:
5277 return Initializer->getLocStart();
5279 llvm_unreachable("missed an InitializedEntity kind?");
5282 /// \brief Make a (potentially elidable) temporary copy of the object
5283 /// provided by the given initializer by calling the appropriate copy
5286 /// \param S The Sema object used for type-checking.
5288 /// \param T The type of the temporary object, which must either be
5289 /// the type of the initializer expression or a superclass thereof.
5291 /// \param Entity The entity being initialized.
5293 /// \param CurInit The initializer expression.
5295 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
5296 /// is permitted in C++03 (but not C++0x) when binding a reference to
5299 /// \returns An expression that copies the initializer expression into
5300 /// a temporary object, or an error expression if a copy could not be
5302 static ExprResult CopyObject(Sema &S,
5304 const InitializedEntity &Entity,
5306 bool IsExtraneousCopy) {
5307 if (CurInit.isInvalid())
5309 // Determine which class type we're copying to.
5310 Expr *CurInitExpr = (Expr *)CurInit.get();
5311 CXXRecordDecl *Class = nullptr;
5312 if (const RecordType *Record = T->getAs<RecordType>())
5313 Class = cast<CXXRecordDecl>(Record->getDecl());
5317 // C++0x [class.copy]p32:
5318 // When certain criteria are met, an implementation is allowed to
5319 // omit the copy/move construction of a class object, even if the
5320 // copy/move constructor and/or destructor for the object have
5321 // side effects. [...]
5322 // - when a temporary class object that has not been bound to a
5323 // reference (12.2) would be copied/moved to a class object
5324 // with the same cv-unqualified type, the copy/move operation
5325 // can be omitted by constructing the temporary object
5326 // directly into the target of the omitted copy/move
5328 // Note that the other three bullets are handled elsewhere. Copy
5329 // elision for return statements and throw expressions are handled as part
5330 // of constructor initialization, while copy elision for exception handlers
5331 // is handled by the run-time.
5332 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
5333 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
5335 // Make sure that the type we are copying is complete.
5336 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
5339 // Perform overload resolution using the class's copy/move constructors.
5340 // Only consider constructors and constructor templates. Per
5341 // C++0x [dcl.init]p16, second bullet to class types, this initialization
5342 // is direct-initialization.
5343 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5344 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
5346 bool HadMultipleCandidates = (CandidateSet.size() > 1);
5348 OverloadCandidateSet::iterator Best;
5349 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
5353 case OR_No_Viable_Function:
5354 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
5355 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
5356 : diag::err_temp_copy_no_viable)
5357 << (int)Entity.getKind() << CurInitExpr->getType()
5358 << CurInitExpr->getSourceRange();
5359 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5360 if (!IsExtraneousCopy || S.isSFINAEContext())
5365 S.Diag(Loc, diag::err_temp_copy_ambiguous)
5366 << (int)Entity.getKind() << CurInitExpr->getType()
5367 << CurInitExpr->getSourceRange();
5368 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5372 S.Diag(Loc, diag::err_temp_copy_deleted)
5373 << (int)Entity.getKind() << CurInitExpr->getType()
5374 << CurInitExpr->getSourceRange();
5375 S.NoteDeletedFunction(Best->Function);
5379 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
5380 SmallVector<Expr*, 8> ConstructorArgs;
5381 CurInit.get(); // Ownership transferred into MultiExprArg, below.
5383 S.CheckConstructorAccess(Loc, Constructor, Entity,
5384 Best->FoundDecl.getAccess(), IsExtraneousCopy);
5386 if (IsExtraneousCopy) {
5387 // If this is a totally extraneous copy for C++03 reference
5388 // binding purposes, just return the original initialization
5389 // expression. We don't generate an (elided) copy operation here
5390 // because doing so would require us to pass down a flag to avoid
5391 // infinite recursion, where each step adds another extraneous,
5394 // Instantiate the default arguments of any extra parameters in
5395 // the selected copy constructor, as if we were going to create a
5396 // proper call to the copy constructor.
5397 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
5398 ParmVarDecl *Parm = Constructor->getParamDecl(I);
5399 if (S.RequireCompleteType(Loc, Parm->getType(),
5400 diag::err_call_incomplete_argument))
5403 // Build the default argument expression; we don't actually care
5404 // if this succeeds or not, because this routine will complain
5405 // if there was a problem.
5406 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5412 // Determine the arguments required to actually perform the
5413 // constructor call (we might have derived-to-base conversions, or
5414 // the copy constructor may have default arguments).
5415 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5418 // Actually perform the constructor call.
5419 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
5421 HadMultipleCandidates,
5423 /*StdInitListInit*/ false,
5425 CXXConstructExpr::CK_Complete,
5428 // If we're supposed to bind temporaries, do so.
5429 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5430 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
5434 /// \brief Check whether elidable copy construction for binding a reference to
5435 /// a temporary would have succeeded if we were building in C++98 mode, for
5437 static void CheckCXX98CompatAccessibleCopy(Sema &S,
5438 const InitializedEntity &Entity,
5439 Expr *CurInitExpr) {
5440 assert(S.getLangOpts().CPlusPlus11);
5442 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5446 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5447 if (S.Diags.isIgnored(diag::warn_cxx98_compat_temp_copy, Loc))
5450 // Find constructors which would have been considered.
5451 OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
5452 LookupCopyAndMoveConstructors(
5453 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5455 // Perform overload resolution.
5456 OverloadCandidateSet::iterator Best;
5457 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5459 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5460 << OR << (int)Entity.getKind() << CurInitExpr->getType()
5461 << CurInitExpr->getSourceRange();
5465 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5466 Entity, Best->FoundDecl.getAccess(), Diag);
5467 // FIXME: Check default arguments as far as that's possible.
5470 case OR_No_Viable_Function:
5472 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5477 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5482 S.NoteDeletedFunction(Best->Function);
5487 void InitializationSequence::PrintInitLocationNote(Sema &S,
5488 const InitializedEntity &Entity) {
5489 if (Entity.isParameterKind() && Entity.getDecl()) {
5490 if (Entity.getDecl()->getLocation().isInvalid())
5493 if (Entity.getDecl()->getDeclName())
5494 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5495 << Entity.getDecl()->getDeclName();
5497 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5499 else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5500 Entity.getMethodDecl())
5501 S.Diag(Entity.getMethodDecl()->getLocation(),
5502 diag::note_method_return_type_change)
5503 << Entity.getMethodDecl()->getDeclName();
5506 static bool isReferenceBinding(const InitializationSequence::Step &s) {
5507 return s.Kind == InitializationSequence::SK_BindReference ||
5508 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5511 /// Returns true if the parameters describe a constructor initialization of
5512 /// an explicit temporary object, e.g. "Point(x, y)".
5513 static bool isExplicitTemporary(const InitializedEntity &Entity,
5514 const InitializationKind &Kind,
5516 switch (Entity.getKind()) {
5517 case InitializedEntity::EK_Temporary:
5518 case InitializedEntity::EK_CompoundLiteralInit:
5519 case InitializedEntity::EK_RelatedResult:
5525 switch (Kind.getKind()) {
5526 case InitializationKind::IK_DirectList:
5528 // FIXME: Hack to work around cast weirdness.
5529 case InitializationKind::IK_Direct:
5530 case InitializationKind::IK_Value:
5531 return NumArgs != 1;
5538 PerformConstructorInitialization(Sema &S,
5539 const InitializedEntity &Entity,
5540 const InitializationKind &Kind,
5542 const InitializationSequence::Step& Step,
5543 bool &ConstructorInitRequiresZeroInit,
5544 bool IsListInitialization,
5545 bool IsStdInitListInitialization,
5546 SourceLocation LBraceLoc,
5547 SourceLocation RBraceLoc) {
5548 unsigned NumArgs = Args.size();
5549 CXXConstructorDecl *Constructor
5550 = cast<CXXConstructorDecl>(Step.Function.Function);
5551 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5553 // Build a call to the selected constructor.
5554 SmallVector<Expr*, 8> ConstructorArgs;
5555 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5556 ? Kind.getEqualLoc()
5557 : Kind.getLocation();
5559 if (Kind.getKind() == InitializationKind::IK_Default) {
5560 // Force even a trivial, implicit default constructor to be
5561 // semantically checked. We do this explicitly because we don't build
5562 // the definition for completely trivial constructors.
5563 assert(Constructor->getParent() && "No parent class for constructor.");
5564 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5565 Constructor->isTrivial() && !Constructor->isUsed(false))
5566 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5569 ExprResult CurInit((Expr *)nullptr);
5571 // C++ [over.match.copy]p1:
5572 // - When initializing a temporary to be bound to the first parameter
5573 // of a constructor that takes a reference to possibly cv-qualified
5574 // T as its first argument, called with a single argument in the
5575 // context of direct-initialization, explicit conversion functions
5576 // are also considered.
5577 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5579 Constructor->isCopyOrMoveConstructor();
5581 // Determine the arguments required to actually perform the constructor
5583 if (S.CompleteConstructorCall(Constructor, Args,
5584 Loc, ConstructorArgs,
5586 IsListInitialization))
5590 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5591 // An explicitly-constructed temporary, e.g., X(1, 2).
5592 S.MarkFunctionReferenced(Loc, Constructor);
5593 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5596 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5598 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5599 SourceRange ParenOrBraceRange =
5600 (Kind.getKind() == InitializationKind::IK_DirectList)
5601 ? SourceRange(LBraceLoc, RBraceLoc)
5602 : Kind.getParenRange();
5604 CurInit = new (S.Context) CXXTemporaryObjectExpr(
5605 S.Context, Constructor, TSInfo, ConstructorArgs, ParenOrBraceRange,
5606 HadMultipleCandidates, IsListInitialization,
5607 IsStdInitListInitialization, ConstructorInitRequiresZeroInit);
5609 CXXConstructExpr::ConstructionKind ConstructKind =
5610 CXXConstructExpr::CK_Complete;
5612 if (Entity.getKind() == InitializedEntity::EK_Base) {
5613 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5614 CXXConstructExpr::CK_VirtualBase :
5615 CXXConstructExpr::CK_NonVirtualBase;
5616 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5617 ConstructKind = CXXConstructExpr::CK_Delegating;
5620 // Only get the parenthesis or brace range if it is a list initialization or
5621 // direct construction.
5622 SourceRange ParenOrBraceRange;
5623 if (IsListInitialization)
5624 ParenOrBraceRange = SourceRange(LBraceLoc, RBraceLoc);
5625 else if (Kind.getKind() == InitializationKind::IK_Direct)
5626 ParenOrBraceRange = Kind.getParenRange();
5628 // If the entity allows NRVO, mark the construction as elidable
5630 if (Entity.allowsNRVO())
5631 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5632 Constructor, /*Elidable=*/true,
5634 HadMultipleCandidates,
5635 IsListInitialization,
5636 IsStdInitListInitialization,
5637 ConstructorInitRequiresZeroInit,
5641 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5644 HadMultipleCandidates,
5645 IsListInitialization,
5646 IsStdInitListInitialization,
5647 ConstructorInitRequiresZeroInit,
5651 if (CurInit.isInvalid())
5654 // Only check access if all of that succeeded.
5655 S.CheckConstructorAccess(Loc, Constructor, Entity,
5656 Step.Function.FoundDecl.getAccess());
5657 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5660 if (shouldBindAsTemporary(Entity))
5661 CurInit = S.MaybeBindToTemporary(CurInit.get());
5666 /// Determine whether the specified InitializedEntity definitely has a lifetime
5667 /// longer than the current full-expression. Conservatively returns false if
5670 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5671 const InitializedEntity *Top = &Entity;
5672 while (Top->getParent())
5673 Top = Top->getParent();
5675 switch (Top->getKind()) {
5676 case InitializedEntity::EK_Variable:
5677 case InitializedEntity::EK_Result:
5678 case InitializedEntity::EK_Exception:
5679 case InitializedEntity::EK_Member:
5680 case InitializedEntity::EK_New:
5681 case InitializedEntity::EK_Base:
5682 case InitializedEntity::EK_Delegating:
5685 case InitializedEntity::EK_ArrayElement:
5686 case InitializedEntity::EK_VectorElement:
5687 case InitializedEntity::EK_BlockElement:
5688 case InitializedEntity::EK_ComplexElement:
5689 // Could not determine what the full initialization is. Assume it might not
5690 // outlive the full-expression.
5693 case InitializedEntity::EK_Parameter:
5694 case InitializedEntity::EK_Parameter_CF_Audited:
5695 case InitializedEntity::EK_Temporary:
5696 case InitializedEntity::EK_LambdaCapture:
5697 case InitializedEntity::EK_CompoundLiteralInit:
5698 case InitializedEntity::EK_RelatedResult:
5699 // The entity being initialized might not outlive the full-expression.
5703 llvm_unreachable("unknown entity kind");
5706 /// Determine the declaration which an initialized entity ultimately refers to,
5707 /// for the purpose of lifetime-extending a temporary bound to a reference in
5708 /// the initialization of \p Entity.
5709 static const InitializedEntity *getEntityForTemporaryLifetimeExtension(
5710 const InitializedEntity *Entity,
5711 const InitializedEntity *FallbackDecl = nullptr) {
5712 // C++11 [class.temporary]p5:
5713 switch (Entity->getKind()) {
5714 case InitializedEntity::EK_Variable:
5715 // The temporary [...] persists for the lifetime of the reference
5718 case InitializedEntity::EK_Member:
5719 // For subobjects, we look at the complete object.
5720 if (Entity->getParent())
5721 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5725 // -- A temporary bound to a reference member in a constructor's
5726 // ctor-initializer persists until the constructor exits.
5729 case InitializedEntity::EK_Parameter:
5730 case InitializedEntity::EK_Parameter_CF_Audited:
5731 // -- A temporary bound to a reference parameter in a function call
5732 // persists until the completion of the full-expression containing
5734 case InitializedEntity::EK_Result:
5735 // -- The lifetime of a temporary bound to the returned value in a
5736 // function return statement is not extended; the temporary is
5737 // destroyed at the end of the full-expression in the return statement.
5738 case InitializedEntity::EK_New:
5739 // -- A temporary bound to a reference in a new-initializer persists
5740 // until the completion of the full-expression containing the
5744 case InitializedEntity::EK_Temporary:
5745 case InitializedEntity::EK_CompoundLiteralInit:
5746 case InitializedEntity::EK_RelatedResult:
5747 // We don't yet know the storage duration of the surrounding temporary.
5748 // Assume it's got full-expression duration for now, it will patch up our
5749 // storage duration if that's not correct.
5752 case InitializedEntity::EK_ArrayElement:
5753 // For subobjects, we look at the complete object.
5754 return getEntityForTemporaryLifetimeExtension(Entity->getParent(),
5757 case InitializedEntity::EK_Base:
5758 case InitializedEntity::EK_Delegating:
5759 // We can reach this case for aggregate initialization in a constructor:
5760 // struct A { int &&r; };
5761 // struct B : A { B() : A{0} {} };
5762 // In this case, use the innermost field decl as the context.
5763 return FallbackDecl;
5765 case InitializedEntity::EK_BlockElement:
5766 case InitializedEntity::EK_LambdaCapture:
5767 case InitializedEntity::EK_Exception:
5768 case InitializedEntity::EK_VectorElement:
5769 case InitializedEntity::EK_ComplexElement:
5772 llvm_unreachable("unknown entity kind");
5775 static void performLifetimeExtension(Expr *Init,
5776 const InitializedEntity *ExtendingEntity);
5778 /// Update a glvalue expression that is used as the initializer of a reference
5779 /// to note that its lifetime is extended.
5780 /// \return \c true if any temporary had its lifetime extended.
5782 performReferenceExtension(Expr *Init,
5783 const InitializedEntity *ExtendingEntity) {
5784 // Walk past any constructs which we can lifetime-extend across.
5789 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5790 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5791 // This is just redundant braces around an initializer. Step over it.
5792 Init = ILE->getInit(0);
5796 // Step over any subobject adjustments; we may have a materialized
5797 // temporary inside them.
5798 SmallVector<const Expr *, 2> CommaLHSs;
5799 SmallVector<SubobjectAdjustment, 2> Adjustments;
5800 Init = const_cast<Expr *>(
5801 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5803 // Per current approach for DR1376, look through casts to reference type
5804 // when performing lifetime extension.
5805 if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5806 if (CE->getSubExpr()->isGLValue())
5807 Init = CE->getSubExpr();
5809 // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5810 // It's unclear if binding a reference to that xvalue extends the array
5812 } while (Init != Old);
5814 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5815 // Update the storage duration of the materialized temporary.
5816 // FIXME: Rebuild the expression instead of mutating it.
5817 ME->setExtendingDecl(ExtendingEntity->getDecl(),
5818 ExtendingEntity->allocateManglingNumber());
5819 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingEntity);
5826 /// Update a prvalue expression that is going to be materialized as a
5827 /// lifetime-extended temporary.
5828 static void performLifetimeExtension(Expr *Init,
5829 const InitializedEntity *ExtendingEntity) {
5830 // Dig out the expression which constructs the extended temporary.
5831 SmallVector<const Expr *, 2> CommaLHSs;
5832 SmallVector<SubobjectAdjustment, 2> Adjustments;
5833 Init = const_cast<Expr *>(
5834 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5836 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5837 Init = BTE->getSubExpr();
5839 if (CXXStdInitializerListExpr *ILE =
5840 dyn_cast<CXXStdInitializerListExpr>(Init)) {
5841 performReferenceExtension(ILE->getSubExpr(), ExtendingEntity);
5845 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5846 if (ILE->getType()->isArrayType()) {
5847 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5848 performLifetimeExtension(ILE->getInit(I), ExtendingEntity);
5852 if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
5853 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5855 // If we lifetime-extend a braced initializer which is initializing an
5856 // aggregate, and that aggregate contains reference members which are
5857 // bound to temporaries, those temporaries are also lifetime-extended.
5858 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5859 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5860 performReferenceExtension(ILE->getInit(0), ExtendingEntity);
5863 for (const auto *I : RD->fields()) {
5864 if (Index >= ILE->getNumInits())
5866 if (I->isUnnamedBitfield())
5868 Expr *SubInit = ILE->getInit(Index);
5869 if (I->getType()->isReferenceType())
5870 performReferenceExtension(SubInit, ExtendingEntity);
5871 else if (isa<InitListExpr>(SubInit) ||
5872 isa<CXXStdInitializerListExpr>(SubInit))
5873 // This may be either aggregate-initialization of a member or
5874 // initialization of a std::initializer_list object. Either way,
5875 // we should recursively lifetime-extend that initializer.
5876 performLifetimeExtension(SubInit, ExtendingEntity);
5884 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5885 const Expr *Init, bool IsInitializerList,
5886 const ValueDecl *ExtendingDecl) {
5887 // Warn if a field lifetime-extends a temporary.
5888 if (isa<FieldDecl>(ExtendingDecl)) {
5889 if (IsInitializerList) {
5890 S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5891 << /*at end of constructor*/true;
5895 bool IsSubobjectMember = false;
5896 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5897 Ent = Ent->getParent()) {
5898 if (Ent->getKind() != InitializedEntity::EK_Base) {
5899 IsSubobjectMember = true;
5903 S.Diag(Init->getExprLoc(),
5904 diag::warn_bind_ref_member_to_temporary)
5905 << ExtendingDecl << Init->getSourceRange()
5906 << IsSubobjectMember << IsInitializerList;
5907 if (IsSubobjectMember)
5908 S.Diag(ExtendingDecl->getLocation(),
5909 diag::note_ref_subobject_of_member_declared_here);
5911 S.Diag(ExtendingDecl->getLocation(),
5912 diag::note_ref_or_ptr_member_declared_here)
5913 << /*is pointer*/false;
5917 static void DiagnoseNarrowingInInitList(Sema &S,
5918 const ImplicitConversionSequence &ICS,
5919 QualType PreNarrowingType,
5920 QualType EntityType,
5921 const Expr *PostInit);
5923 /// Provide warnings when std::move is used on construction.
5924 static void CheckMoveOnConstruction(Sema &S, const Expr *InitExpr,
5925 bool IsReturnStmt) {
5929 if (!S.ActiveTemplateInstantiations.empty())
5932 QualType DestType = InitExpr->getType();
5933 if (!DestType->isRecordType())
5936 unsigned DiagID = 0;
5938 const CXXConstructExpr *CCE =
5939 dyn_cast<CXXConstructExpr>(InitExpr->IgnoreParens());
5940 if (!CCE || CCE->getNumArgs() != 1)
5943 if (!CCE->getConstructor()->isCopyOrMoveConstructor())
5946 InitExpr = CCE->getArg(0)->IgnoreImpCasts();
5949 // Find the std::move call and get the argument.
5950 const CallExpr *CE = dyn_cast<CallExpr>(InitExpr->IgnoreParens());
5951 if (!CE || CE->getNumArgs() != 1)
5954 const FunctionDecl *MoveFunction = CE->getDirectCallee();
5955 if (!MoveFunction || !MoveFunction->isInStdNamespace() ||
5956 !MoveFunction->getIdentifier() ||
5957 !MoveFunction->getIdentifier()->isStr("move"))
5960 const Expr *Arg = CE->getArg(0)->IgnoreImplicit();
5963 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts());
5964 if (!DRE || DRE->refersToEnclosingVariableOrCapture())
5967 const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl());
5968 if (!VD || !VD->hasLocalStorage())
5971 QualType SourceType = VD->getType();
5972 if (!SourceType->isRecordType())
5975 if (!S.Context.hasSameUnqualifiedType(DestType, SourceType)) {
5979 // If we're returning a function parameter, copy elision
5981 if (isa<ParmVarDecl>(VD))
5982 DiagID = diag::warn_redundant_move_on_return;
5984 DiagID = diag::warn_pessimizing_move_on_return;
5986 DiagID = diag::warn_pessimizing_move_on_initialization;
5987 const Expr *ArgStripped = Arg->IgnoreImplicit()->IgnoreParens();
5988 if (!ArgStripped->isRValue() || !ArgStripped->getType()->isRecordType())
5992 S.Diag(CE->getLocStart(), DiagID);
5994 // Get all the locations for a fix-it. Don't emit the fix-it if any location
5995 // is within a macro.
5996 SourceLocation CallBegin = CE->getCallee()->getLocStart();
5997 if (CallBegin.isMacroID())
5999 SourceLocation RParen = CE->getRParenLoc();
6000 if (RParen.isMacroID())
6002 SourceLocation LParen;
6003 SourceLocation ArgLoc = Arg->getLocStart();
6005 // Special testing for the argument location. Since the fix-it needs the
6006 // location right before the argument, the argument location can be in a
6007 // macro only if it is at the beginning of the macro.
6008 while (ArgLoc.isMacroID() &&
6009 S.getSourceManager().isAtStartOfImmediateMacroExpansion(ArgLoc)) {
6010 ArgLoc = S.getSourceManager().getImmediateExpansionRange(ArgLoc).first;
6013 if (LParen.isMacroID())
6016 LParen = ArgLoc.getLocWithOffset(-1);
6018 S.Diag(CE->getLocStart(), diag::note_remove_move)
6019 << FixItHint::CreateRemoval(SourceRange(CallBegin, LParen))
6020 << FixItHint::CreateRemoval(SourceRange(RParen, RParen));
6024 InitializationSequence::Perform(Sema &S,
6025 const InitializedEntity &Entity,
6026 const InitializationKind &Kind,
6028 QualType *ResultType) {
6030 Diagnose(S, Entity, Kind, Args);
6033 if (!ZeroInitializationFixit.empty()) {
6034 unsigned DiagID = diag::err_default_init_const;
6035 if (Decl *D = Entity.getDecl())
6036 if (S.getLangOpts().MSVCCompat && D->hasAttr<SelectAnyAttr>())
6037 DiagID = diag::ext_default_init_const;
6039 // The initialization would have succeeded with this fixit. Since the fixit
6040 // is on the error, we need to build a valid AST in this case, so this isn't
6041 // handled in the Failed() branch above.
6042 QualType DestType = Entity.getType();
6043 S.Diag(Kind.getLocation(), DiagID)
6044 << DestType << (bool)DestType->getAs<RecordType>()
6045 << FixItHint::CreateInsertion(ZeroInitializationFixitLoc,
6046 ZeroInitializationFixit);
6049 if (getKind() == DependentSequence) {
6050 // If the declaration is a non-dependent, incomplete array type
6051 // that has an initializer, then its type will be completed once
6052 // the initializer is instantiated.
6053 if (ResultType && !Entity.getType()->isDependentType() &&
6055 QualType DeclType = Entity.getType();
6056 if (const IncompleteArrayType *ArrayT
6057 = S.Context.getAsIncompleteArrayType(DeclType)) {
6058 // FIXME: We don't currently have the ability to accurately
6059 // compute the length of an initializer list without
6060 // performing full type-checking of the initializer list
6061 // (since we have to determine where braces are implicitly
6062 // introduced and such). So, we fall back to making the array
6063 // type a dependently-sized array type with no specified
6065 if (isa<InitListExpr>((Expr *)Args[0])) {
6066 SourceRange Brackets;
6068 // Scavange the location of the brackets from the entity, if we can.
6069 if (DeclaratorDecl *DD = Entity.getDecl()) {
6070 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
6071 TypeLoc TL = TInfo->getTypeLoc();
6072 if (IncompleteArrayTypeLoc ArrayLoc =
6073 TL.getAs<IncompleteArrayTypeLoc>())
6074 Brackets = ArrayLoc.getBracketsRange();
6079 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
6080 /*NumElts=*/nullptr,
6081 ArrayT->getSizeModifier(),
6082 ArrayT->getIndexTypeCVRQualifiers(),
6088 if (Kind.getKind() == InitializationKind::IK_Direct &&
6089 !Kind.isExplicitCast()) {
6090 // Rebuild the ParenListExpr.
6091 SourceRange ParenRange = Kind.getParenRange();
6092 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
6095 assert(Kind.getKind() == InitializationKind::IK_Copy ||
6096 Kind.isExplicitCast() ||
6097 Kind.getKind() == InitializationKind::IK_DirectList);
6098 return ExprResult(Args[0]);
6101 // No steps means no initialization.
6103 return ExprResult((Expr *)nullptr);
6105 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
6106 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
6107 !Entity.isParameterKind()) {
6108 // Produce a C++98 compatibility warning if we are initializing a reference
6109 // from an initializer list. For parameters, we produce a better warning
6111 Expr *Init = Args[0];
6112 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
6113 << Init->getSourceRange();
6116 // Diagnose cases where we initialize a pointer to an array temporary, and the
6117 // pointer obviously outlives the temporary.
6118 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
6119 Entity.getType()->isPointerType() &&
6120 InitializedEntityOutlivesFullExpression(Entity)) {
6121 Expr *Init = Args[0];
6122 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
6123 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
6124 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
6125 << Init->getSourceRange();
6128 QualType DestType = Entity.getType().getNonReferenceType();
6129 // FIXME: Ugly hack around the fact that Entity.getType() is not
6130 // the same as Entity.getDecl()->getType() in cases involving type merging,
6131 // and we want latter when it makes sense.
6133 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
6136 ExprResult CurInit((Expr *)nullptr);
6138 // For initialization steps that start with a single initializer,
6139 // grab the only argument out the Args and place it into the "current"
6141 switch (Steps.front().Kind) {
6142 case SK_ResolveAddressOfOverloadedFunction:
6143 case SK_CastDerivedToBaseRValue:
6144 case SK_CastDerivedToBaseXValue:
6145 case SK_CastDerivedToBaseLValue:
6146 case SK_BindReference:
6147 case SK_BindReferenceToTemporary:
6148 case SK_ExtraneousCopyToTemporary:
6149 case SK_UserConversion:
6150 case SK_QualificationConversionLValue:
6151 case SK_QualificationConversionXValue:
6152 case SK_QualificationConversionRValue:
6153 case SK_AtomicConversion:
6154 case SK_LValueToRValue:
6155 case SK_ConversionSequence:
6156 case SK_ConversionSequenceNoNarrowing:
6157 case SK_ListInitialization:
6158 case SK_UnwrapInitList:
6159 case SK_RewrapInitList:
6160 case SK_CAssignment:
6162 case SK_ObjCObjectConversion:
6164 case SK_ParenthesizedArrayInit:
6165 case SK_PassByIndirectCopyRestore:
6166 case SK_PassByIndirectRestore:
6167 case SK_ProduceObjCObject:
6168 case SK_StdInitializerList:
6169 case SK_OCLSamplerInit:
6170 case SK_OCLZeroEvent: {
6171 assert(Args.size() == 1);
6173 if (!CurInit.get()) return ExprError();
6177 case SK_ConstructorInitialization:
6178 case SK_ConstructorInitializationFromList:
6179 case SK_StdInitializerListConstructorCall:
6180 case SK_ZeroInitialization:
6184 // Walk through the computed steps for the initialization sequence,
6185 // performing the specified conversions along the way.
6186 bool ConstructorInitRequiresZeroInit = false;
6187 for (step_iterator Step = step_begin(), StepEnd = step_end();
6188 Step != StepEnd; ++Step) {
6189 if (CurInit.isInvalid())
6192 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
6194 switch (Step->Kind) {
6195 case SK_ResolveAddressOfOverloadedFunction:
6196 // Overload resolution determined which function invoke; update the
6197 // initializer to reflect that choice.
6198 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
6199 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
6201 CurInit = S.FixOverloadedFunctionReference(CurInit,
6202 Step->Function.FoundDecl,
6203 Step->Function.Function);
6206 case SK_CastDerivedToBaseRValue:
6207 case SK_CastDerivedToBaseXValue:
6208 case SK_CastDerivedToBaseLValue: {
6209 // We have a derived-to-base cast that produces either an rvalue or an
6210 // lvalue. Perform that cast.
6212 CXXCastPath BasePath;
6214 // Casts to inaccessible base classes are allowed with C-style casts.
6215 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
6216 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
6217 CurInit.get()->getLocStart(),
6218 CurInit.get()->getSourceRange(),
6219 &BasePath, IgnoreBaseAccess))
6223 Step->Kind == SK_CastDerivedToBaseLValue ?
6225 (Step->Kind == SK_CastDerivedToBaseXValue ?
6229 ImplicitCastExpr::Create(S.Context, Step->Type, CK_DerivedToBase,
6230 CurInit.get(), &BasePath, VK);
6234 case SK_BindReference:
6235 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
6236 if (CurInit.get()->refersToBitField()) {
6237 // We don't necessarily have an unambiguous source bit-field.
6238 FieldDecl *BitField = CurInit.get()->getSourceBitField();
6239 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
6240 << Entity.getType().isVolatileQualified()
6241 << (BitField ? BitField->getDeclName() : DeclarationName())
6242 << (BitField != nullptr)
6243 << CurInit.get()->getSourceRange();
6245 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
6250 if (CurInit.get()->refersToVectorElement()) {
6251 // References cannot bind to vector elements.
6252 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
6253 << Entity.getType().isVolatileQualified()
6254 << CurInit.get()->getSourceRange();
6255 PrintInitLocationNote(S, Entity);
6259 // Reference binding does not have any corresponding ASTs.
6261 // Check exception specifications
6262 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6265 // Even though we didn't materialize a temporary, the binding may still
6266 // extend the lifetime of a temporary. This happens if we bind a reference
6267 // to the result of a cast to reference type.
6268 if (const InitializedEntity *ExtendingEntity =
6269 getEntityForTemporaryLifetimeExtension(&Entity))
6270 if (performReferenceExtension(CurInit.get(), ExtendingEntity))
6271 warnOnLifetimeExtension(S, Entity, CurInit.get(),
6272 /*IsInitializerList=*/false,
6273 ExtendingEntity->getDecl());
6277 case SK_BindReferenceToTemporary: {
6278 // Make sure the "temporary" is actually an rvalue.
6279 assert(CurInit.get()->isRValue() && "not a temporary");
6281 // Check exception specifications
6282 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
6285 // Materialize the temporary into memory.
6286 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
6287 Entity.getType().getNonReferenceType(), CurInit.get(),
6288 Entity.getType()->isLValueReferenceType());
6290 // Maybe lifetime-extend the temporary's subobjects to match the
6291 // entity's lifetime.
6292 if (const InitializedEntity *ExtendingEntity =
6293 getEntityForTemporaryLifetimeExtension(&Entity))
6294 if (performReferenceExtension(MTE, ExtendingEntity))
6295 warnOnLifetimeExtension(S, Entity, CurInit.get(), /*IsInitializerList=*/false,
6296 ExtendingEntity->getDecl());
6298 // If we're binding to an Objective-C object that has lifetime, we
6299 // need cleanups. Likewise if we're extending this temporary to automatic
6300 // storage duration -- we need to register its cleanup during the
6301 // full-expression's cleanups.
6302 if ((S.getLangOpts().ObjCAutoRefCount &&
6303 MTE->getType()->isObjCLifetimeType()) ||
6304 (MTE->getStorageDuration() == SD_Automatic &&
6305 MTE->getType().isDestructedType()))
6306 S.ExprNeedsCleanups = true;
6312 case SK_ExtraneousCopyToTemporary:
6313 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
6314 /*IsExtraneousCopy=*/true);
6317 case SK_UserConversion: {
6318 // We have a user-defined conversion that invokes either a constructor
6319 // or a conversion function.
6321 bool IsCopy = false;
6322 FunctionDecl *Fn = Step->Function.Function;
6323 DeclAccessPair FoundFn = Step->Function.FoundDecl;
6324 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
6325 bool CreatedObject = false;
6326 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
6327 // Build a call to the selected constructor.
6328 SmallVector<Expr*, 8> ConstructorArgs;
6329 SourceLocation Loc = CurInit.get()->getLocStart();
6330 CurInit.get(); // Ownership transferred into MultiExprArg, below.
6332 // Determine the arguments required to actually perform the constructor
6334 Expr *Arg = CurInit.get();
6335 if (S.CompleteConstructorCall(Constructor,
6336 MultiExprArg(&Arg, 1),
6337 Loc, ConstructorArgs))
6340 // Build an expression that constructs a temporary.
6341 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
6343 HadMultipleCandidates,
6345 /*StdInitListInit*/ false,
6347 CXXConstructExpr::CK_Complete,
6349 if (CurInit.isInvalid())
6352 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
6353 FoundFn.getAccess());
6354 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6357 CastKind = CK_ConstructorConversion;
6358 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
6359 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
6360 S.IsDerivedFrom(SourceType, Class))
6363 CreatedObject = true;
6365 // Build a call to the conversion function.
6366 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
6367 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr,
6369 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
6372 // FIXME: Should we move this initialization into a separate
6373 // derived-to-base conversion? I believe the answer is "no", because
6374 // we don't want to turn off access control here for c-style casts.
6375 ExprResult CurInitExprRes =
6376 S.PerformObjectArgumentInitialization(CurInit.get(),
6377 /*Qualifier=*/nullptr,
6378 FoundFn, Conversion);
6379 if(CurInitExprRes.isInvalid())
6381 CurInit = CurInitExprRes;
6383 // Build the actual call to the conversion function.
6384 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
6385 HadMultipleCandidates);
6386 if (CurInit.isInvalid() || !CurInit.get())
6389 CastKind = CK_UserDefinedConversion;
6391 CreatedObject = Conversion->getReturnType()->isRecordType();
6394 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
6395 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
6397 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
6398 QualType T = CurInit.get()->getType();
6399 if (const RecordType *Record = T->getAs<RecordType>()) {
6400 CXXDestructorDecl *Destructor
6401 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
6402 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
6403 S.PDiag(diag::err_access_dtor_temp) << T);
6404 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
6405 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
6410 CurInit = ImplicitCastExpr::Create(S.Context, CurInit.get()->getType(),
6411 CastKind, CurInit.get(), nullptr,
6412 CurInit.get()->getValueKind());
6413 if (MaybeBindToTemp)
6414 CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
6416 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
6417 CurInit, /*IsExtraneousCopy=*/false);
6421 case SK_QualificationConversionLValue:
6422 case SK_QualificationConversionXValue:
6423 case SK_QualificationConversionRValue: {
6424 // Perform a qualification conversion; these can never go wrong.
6426 Step->Kind == SK_QualificationConversionLValue ?
6428 (Step->Kind == SK_QualificationConversionXValue ?
6431 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type, CK_NoOp, VK);
6435 case SK_AtomicConversion: {
6436 assert(CurInit.get()->isRValue() && "cannot convert glvalue to atomic");
6437 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6438 CK_NonAtomicToAtomic, VK_RValue);
6442 case SK_LValueToRValue: {
6443 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
6444 CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
6445 CK_LValueToRValue, CurInit.get(),
6446 /*BasePath=*/nullptr, VK_RValue);
6450 case SK_ConversionSequence:
6451 case SK_ConversionSequenceNoNarrowing: {
6452 Sema::CheckedConversionKind CCK
6453 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
6454 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
6455 : Kind.isExplicitCast()? Sema::CCK_OtherCast
6456 : Sema::CCK_ImplicitConversion;
6457 ExprResult CurInitExprRes =
6458 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
6459 getAssignmentAction(Entity), CCK);
6460 if (CurInitExprRes.isInvalid())
6462 CurInit = CurInitExprRes;
6464 if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
6465 S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
6466 DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
6471 case SK_ListInitialization: {
6472 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
6473 // If we're not initializing the top-level entity, we need to create an
6474 // InitializeTemporary entity for our target type.
6475 QualType Ty = Step->Type;
6476 bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
6477 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
6478 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
6479 InitListChecker PerformInitList(S, InitEntity,
6480 InitList, Ty, /*VerifyOnly=*/false);
6481 if (PerformInitList.HadError())
6484 // Hack: We must update *ResultType if available in order to set the
6485 // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
6486 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
6488 ResultType->getNonReferenceType()->isIncompleteArrayType()) {
6489 if ((*ResultType)->isRValueReferenceType())
6490 Ty = S.Context.getRValueReferenceType(Ty);
6491 else if ((*ResultType)->isLValueReferenceType())
6492 Ty = S.Context.getLValueReferenceType(Ty,
6493 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
6497 InitListExpr *StructuredInitList =
6498 PerformInitList.getFullyStructuredList();
6500 CurInit = shouldBindAsTemporary(InitEntity)
6501 ? S.MaybeBindToTemporary(StructuredInitList)
6502 : StructuredInitList;
6506 case SK_ConstructorInitializationFromList: {
6507 // When an initializer list is passed for a parameter of type "reference
6508 // to object", we don't get an EK_Temporary entity, but instead an
6509 // EK_Parameter entity with reference type.
6510 // FIXME: This is a hack. What we really should do is create a user
6511 // conversion step for this case, but this makes it considerably more
6512 // complicated. For now, this will do.
6513 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6514 Entity.getType().getNonReferenceType());
6515 bool UseTemporary = Entity.getType()->isReferenceType();
6516 assert(Args.size() == 1 && "expected a single argument for list init");
6517 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6518 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6519 << InitList->getSourceRange();
6520 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6521 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6524 ConstructorInitRequiresZeroInit,
6525 /*IsListInitialization*/true,
6526 /*IsStdInitListInit*/false,
6527 InitList->getLBraceLoc(),
6528 InitList->getRBraceLoc());
6532 case SK_UnwrapInitList:
6533 CurInit = cast<InitListExpr>(CurInit.get())->getInit(0);
6536 case SK_RewrapInitList: {
6537 Expr *E = CurInit.get();
6538 InitListExpr *Syntactic = Step->WrappingSyntacticList;
6539 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6540 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6541 ILE->setSyntacticForm(Syntactic);
6542 ILE->setType(E->getType());
6543 ILE->setValueKind(E->getValueKind());
6548 case SK_ConstructorInitialization:
6549 case SK_StdInitializerListConstructorCall: {
6550 // When an initializer list is passed for a parameter of type "reference
6551 // to object", we don't get an EK_Temporary entity, but instead an
6552 // EK_Parameter entity with reference type.
6553 // FIXME: This is a hack. What we really should do is create a user
6554 // conversion step for this case, but this makes it considerably more
6555 // complicated. For now, this will do.
6556 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6557 Entity.getType().getNonReferenceType());
6558 bool UseTemporary = Entity.getType()->isReferenceType();
6559 bool IsStdInitListInit =
6560 Step->Kind == SK_StdInitializerListConstructorCall;
6561 CurInit = PerformConstructorInitialization(
6562 S, UseTemporary ? TempEntity : Entity, Kind, Args, *Step,
6563 ConstructorInitRequiresZeroInit,
6564 /*IsListInitialization*/IsStdInitListInit,
6565 /*IsStdInitListInitialization*/IsStdInitListInit,
6566 /*LBraceLoc*/SourceLocation(),
6567 /*RBraceLoc*/SourceLocation());
6571 case SK_ZeroInitialization: {
6572 step_iterator NextStep = Step;
6574 if (NextStep != StepEnd &&
6575 (NextStep->Kind == SK_ConstructorInitialization ||
6576 NextStep->Kind == SK_ConstructorInitializationFromList)) {
6577 // The need for zero-initialization is recorded directly into
6578 // the call to the object's constructor within the next step.
6579 ConstructorInitRequiresZeroInit = true;
6580 } else if (Kind.getKind() == InitializationKind::IK_Value &&
6581 S.getLangOpts().CPlusPlus &&
6582 !Kind.isImplicitValueInit()) {
6583 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6585 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
6586 Kind.getRange().getBegin());
6588 CurInit = new (S.Context) CXXScalarValueInitExpr(
6589 TSInfo->getType().getNonLValueExprType(S.Context), TSInfo,
6590 Kind.getRange().getEnd());
6592 CurInit = new (S.Context) ImplicitValueInitExpr(Step->Type);
6597 case SK_CAssignment: {
6598 QualType SourceType = CurInit.get()->getType();
6599 ExprResult Result = CurInit;
6600 Sema::AssignConvertType ConvTy =
6601 S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6602 Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
6603 if (Result.isInvalid())
6607 // If this is a call, allow conversion to a transparent union.
6608 ExprResult CurInitExprRes = CurInit;
6609 if (ConvTy != Sema::Compatible &&
6610 Entity.isParameterKind() &&
6611 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
6612 == Sema::Compatible)
6613 ConvTy = Sema::Compatible;
6614 if (CurInitExprRes.isInvalid())
6616 CurInit = CurInitExprRes;
6619 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6620 Step->Type, SourceType,
6622 getAssignmentAction(Entity, true),
6624 PrintInitLocationNote(S, Entity);
6626 } else if (Complained)
6627 PrintInitLocationNote(S, Entity);
6631 case SK_StringInit: {
6632 QualType Ty = Step->Type;
6633 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
6634 S.Context.getAsArrayType(Ty), S);
6638 case SK_ObjCObjectConversion:
6639 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6640 CK_ObjCObjectLValueCast,
6641 CurInit.get()->getValueKind());
6645 // Okay: we checked everything before creating this step. Note that
6646 // this is a GNU extension.
6647 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
6648 << Step->Type << CurInit.get()->getType()
6649 << CurInit.get()->getSourceRange();
6651 // If the destination type is an incomplete array type, update the
6652 // type accordingly.
6654 if (const IncompleteArrayType *IncompleteDest
6655 = S.Context.getAsIncompleteArrayType(Step->Type)) {
6656 if (const ConstantArrayType *ConstantSource
6657 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
6658 *ResultType = S.Context.getConstantArrayType(
6659 IncompleteDest->getElementType(),
6660 ConstantSource->getSize(),
6661 ArrayType::Normal, 0);
6667 case SK_ParenthesizedArrayInit:
6668 // Okay: we checked everything before creating this step. Note that
6669 // this is a GNU extension.
6670 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6671 << CurInit.get()->getSourceRange();
6674 case SK_PassByIndirectCopyRestore:
6675 case SK_PassByIndirectRestore:
6676 checkIndirectCopyRestoreSource(S, CurInit.get());
6677 CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
6678 CurInit.get(), Step->Type,
6679 Step->Kind == SK_PassByIndirectCopyRestore);
6682 case SK_ProduceObjCObject:
6684 ImplicitCastExpr::Create(S.Context, Step->Type, CK_ARCProduceObject,
6685 CurInit.get(), nullptr, VK_RValue);
6688 case SK_StdInitializerList: {
6689 S.Diag(CurInit.get()->getExprLoc(),
6690 diag::warn_cxx98_compat_initializer_list_init)
6691 << CurInit.get()->getSourceRange();
6693 // Materialize the temporary into memory.
6694 MaterializeTemporaryExpr *MTE = new (S.Context)
6695 MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
6696 /*BoundToLvalueReference=*/false);
6698 // Maybe lifetime-extend the array temporary's subobjects to match the
6699 // entity's lifetime.
6700 if (const InitializedEntity *ExtendingEntity =
6701 getEntityForTemporaryLifetimeExtension(&Entity))
6702 if (performReferenceExtension(MTE, ExtendingEntity))
6703 warnOnLifetimeExtension(S, Entity, CurInit.get(),
6704 /*IsInitializerList=*/true,
6705 ExtendingEntity->getDecl());
6707 // Wrap it in a construction of a std::initializer_list<T>.
6708 CurInit = new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE);
6710 // Bind the result, in case the library has given initializer_list a
6711 // non-trivial destructor.
6712 if (shouldBindAsTemporary(Entity))
6713 CurInit = S.MaybeBindToTemporary(CurInit.get());
6717 case SK_OCLSamplerInit: {
6718 assert(Step->Type->isSamplerT() &&
6719 "Sampler initialization on non-sampler type.");
6721 QualType SourceType = CurInit.get()->getType();
6723 if (Entity.isParameterKind()) {
6724 if (!SourceType->isSamplerT())
6725 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6727 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
6728 llvm_unreachable("Invalid EntityKind!");
6733 case SK_OCLZeroEvent: {
6734 assert(Step->Type->isEventT() &&
6735 "Event initialization on non-event type.");
6737 CurInit = S.ImpCastExprToType(CurInit.get(), Step->Type,
6739 CurInit.get()->getValueKind());
6745 // Diagnose non-fatal problems with the completed initialization.
6746 if (Entity.getKind() == InitializedEntity::EK_Member &&
6747 cast<FieldDecl>(Entity.getDecl())->isBitField())
6748 S.CheckBitFieldInitialization(Kind.getLocation(),
6749 cast<FieldDecl>(Entity.getDecl()),
6752 // Check for std::move on construction.
6753 if (const Expr *E = CurInit.get()) {
6754 CheckMoveOnConstruction(S, E,
6755 Entity.getKind() == InitializedEntity::EK_Result);
6761 /// Somewhere within T there is an uninitialized reference subobject.
6762 /// Dig it out and diagnose it.
6763 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6765 if (T->isReferenceType()) {
6766 S.Diag(Loc, diag::err_reference_without_init)
6767 << T.getNonReferenceType();
6771 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6772 if (!RD || !RD->hasUninitializedReferenceMember())
6775 for (const auto *FI : RD->fields()) {
6776 if (FI->isUnnamedBitfield())
6779 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6780 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6785 for (const auto &BI : RD->bases()) {
6786 if (DiagnoseUninitializedReference(S, BI.getLocStart(), BI.getType())) {
6787 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6796 //===----------------------------------------------------------------------===//
6797 // Diagnose initialization failures
6798 //===----------------------------------------------------------------------===//
6800 /// Emit notes associated with an initialization that failed due to a
6801 /// "simple" conversion failure.
6802 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6804 QualType destType = entity.getType();
6805 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6806 op->getType()->isObjCObjectPointerType()) {
6808 // Emit a possible note about the conversion failing because the
6809 // operand is a message send with a related result type.
6810 S.EmitRelatedResultTypeNote(op);
6812 // Emit a possible note about a return failing because we're
6813 // expecting a related result type.
6814 if (entity.getKind() == InitializedEntity::EK_Result)
6815 S.EmitRelatedResultTypeNoteForReturn(destType);
6819 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6820 InitListExpr *InitList) {
6821 QualType DestType = Entity.getType();
6824 if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6825 QualType ArrayType = S.Context.getConstantArrayType(
6827 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6828 InitList->getNumInits()),
6829 clang::ArrayType::Normal, 0);
6830 InitializedEntity HiddenArray =
6831 InitializedEntity::InitializeTemporary(ArrayType);
6832 return diagnoseListInit(S, HiddenArray, InitList);
6835 if (DestType->isReferenceType()) {
6836 // A list-initialization failure for a reference means that we tried to
6837 // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
6838 // inner initialization failed.
6839 QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
6840 diagnoseListInit(S, InitializedEntity::InitializeTemporary(T), InitList);
6841 SourceLocation Loc = InitList->getLocStart();
6842 if (auto *D = Entity.getDecl())
6843 Loc = D->getLocation();
6844 S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
6848 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6849 /*VerifyOnly=*/false);
6850 assert(DiagnoseInitList.HadError() &&
6851 "Inconsistent init list check result.");
6854 bool InitializationSequence::Diagnose(Sema &S,
6855 const InitializedEntity &Entity,
6856 const InitializationKind &Kind,
6857 ArrayRef<Expr *> Args) {
6861 QualType DestType = Entity.getType();
6863 case FK_TooManyInitsForReference:
6864 // FIXME: Customize for the initialized entity?
6866 // Dig out the reference subobject which is uninitialized and diagnose it.
6867 // If this is value-initialization, this could be nested some way within
6869 assert(Kind.getKind() == InitializationKind::IK_Value ||
6870 DestType->isReferenceType());
6872 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6873 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6875 } else // FIXME: diagnostic below could be better!
6876 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
6877 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
6880 case FK_ArrayNeedsInitList:
6881 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
6883 case FK_ArrayNeedsInitListOrStringLiteral:
6884 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6886 case FK_ArrayNeedsInitListOrWideStringLiteral:
6887 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6889 case FK_NarrowStringIntoWideCharArray:
6890 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6892 case FK_WideStringIntoCharArray:
6893 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6895 case FK_IncompatWideStringIntoWideChar:
6896 S.Diag(Kind.getLocation(),
6897 diag::err_array_init_incompat_wide_string_into_wchar);
6899 case FK_ArrayTypeMismatch:
6900 case FK_NonConstantArrayInit:
6901 S.Diag(Kind.getLocation(),
6902 (Failure == FK_ArrayTypeMismatch
6903 ? diag::err_array_init_different_type
6904 : diag::err_array_init_non_constant_array))
6905 << DestType.getNonReferenceType()
6906 << Args[0]->getType()
6907 << Args[0]->getSourceRange();
6910 case FK_VariableLengthArrayHasInitializer:
6911 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6912 << Args[0]->getSourceRange();
6915 case FK_AddressOfOverloadFailed: {
6916 DeclAccessPair Found;
6917 S.ResolveAddressOfOverloadedFunction(Args[0],
6918 DestType.getNonReferenceType(),
6924 case FK_ReferenceInitOverloadFailed:
6925 case FK_UserConversionOverloadFailed:
6926 switch (FailedOverloadResult) {
6928 if (Failure == FK_UserConversionOverloadFailed)
6929 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6930 << Args[0]->getType() << DestType
6931 << Args[0]->getSourceRange();
6933 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6934 << DestType << Args[0]->getType()
6935 << Args[0]->getSourceRange();
6937 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6940 case OR_No_Viable_Function:
6941 if (!S.RequireCompleteType(Kind.getLocation(),
6942 DestType.getNonReferenceType(),
6943 diag::err_typecheck_nonviable_condition_incomplete,
6944 Args[0]->getType(), Args[0]->getSourceRange()))
6945 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6946 << Args[0]->getType() << Args[0]->getSourceRange()
6947 << DestType.getNonReferenceType();
6949 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6953 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6954 << Args[0]->getType() << DestType.getNonReferenceType()
6955 << Args[0]->getSourceRange();
6956 OverloadCandidateSet::iterator Best;
6957 OverloadingResult Ovl
6958 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6960 if (Ovl == OR_Deleted) {
6961 S.NoteDeletedFunction(Best->Function);
6963 llvm_unreachable("Inconsistent overload resolution?");
6969 llvm_unreachable("Conversion did not fail!");
6973 case FK_NonConstLValueReferenceBindingToTemporary:
6974 if (isa<InitListExpr>(Args[0])) {
6975 S.Diag(Kind.getLocation(),
6976 diag::err_lvalue_reference_bind_to_initlist)
6977 << DestType.getNonReferenceType().isVolatileQualified()
6978 << DestType.getNonReferenceType()
6979 << Args[0]->getSourceRange();
6982 // Intentional fallthrough
6984 case FK_NonConstLValueReferenceBindingToUnrelated:
6985 S.Diag(Kind.getLocation(),
6986 Failure == FK_NonConstLValueReferenceBindingToTemporary
6987 ? diag::err_lvalue_reference_bind_to_temporary
6988 : diag::err_lvalue_reference_bind_to_unrelated)
6989 << DestType.getNonReferenceType().isVolatileQualified()
6990 << DestType.getNonReferenceType()
6991 << Args[0]->getType()
6992 << Args[0]->getSourceRange();
6995 case FK_RValueReferenceBindingToLValue:
6996 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
6997 << DestType.getNonReferenceType() << Args[0]->getType()
6998 << Args[0]->getSourceRange();
7001 case FK_ReferenceInitDropsQualifiers: {
7002 QualType SourceType = Args[0]->getType();
7003 QualType NonRefType = DestType.getNonReferenceType();
7004 Qualifiers DroppedQualifiers =
7005 SourceType.getQualifiers() - NonRefType.getQualifiers();
7007 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
7010 << DroppedQualifiers.getCVRQualifiers()
7011 << Args[0]->getSourceRange();
7015 case FK_ReferenceInitFailed:
7016 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
7017 << DestType.getNonReferenceType()
7018 << Args[0]->isLValue()
7019 << Args[0]->getType()
7020 << Args[0]->getSourceRange();
7021 emitBadConversionNotes(S, Entity, Args[0]);
7024 case FK_ConversionFailed: {
7025 QualType FromType = Args[0]->getType();
7026 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
7027 << (int)Entity.getKind()
7029 << Args[0]->isLValue()
7031 << Args[0]->getSourceRange();
7032 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
7033 S.Diag(Kind.getLocation(), PDiag);
7034 emitBadConversionNotes(S, Entity, Args[0]);
7038 case FK_ConversionFromPropertyFailed:
7039 // No-op. This error has already been reported.
7042 case FK_TooManyInitsForScalar: {
7045 auto *InitList = dyn_cast<InitListExpr>(Args[0]);
7046 if (InitList && InitList->getNumInits() == 1)
7047 R = SourceRange(InitList->getInit(0)->getLocEnd(), InitList->getLocEnd());
7049 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
7051 R.setBegin(S.getLocForEndOfToken(R.getBegin()));
7052 if (Kind.isCStyleOrFunctionalCast())
7053 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
7056 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
7057 << /*scalar=*/2 << R;
7061 case FK_ReferenceBindingToInitList:
7062 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
7063 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
7066 case FK_InitListBadDestinationType:
7067 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
7068 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
7071 case FK_ListConstructorOverloadFailed:
7072 case FK_ConstructorOverloadFailed: {
7073 SourceRange ArgsRange;
7075 ArgsRange = SourceRange(Args.front()->getLocStart(),
7076 Args.back()->getLocEnd());
7078 if (Failure == FK_ListConstructorOverloadFailed) {
7079 assert(Args.size() == 1 &&
7080 "List construction from other than 1 argument.");
7081 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7082 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
7085 // FIXME: Using "DestType" for the entity we're printing is probably
7087 switch (FailedOverloadResult) {
7089 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
7090 << DestType << ArgsRange;
7091 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
7094 case OR_No_Viable_Function:
7095 if (Kind.getKind() == InitializationKind::IK_Default &&
7096 (Entity.getKind() == InitializedEntity::EK_Base ||
7097 Entity.getKind() == InitializedEntity::EK_Member) &&
7098 isa<CXXConstructorDecl>(S.CurContext)) {
7099 // This is implicit default initialization of a member or
7100 // base within a constructor. If no viable function was
7101 // found, notify the user that she needs to explicitly
7102 // initialize this base/member.
7103 CXXConstructorDecl *Constructor
7104 = cast<CXXConstructorDecl>(S.CurContext);
7105 if (Entity.getKind() == InitializedEntity::EK_Base) {
7106 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7107 << (Constructor->getInheritedConstructor() ? 2 :
7108 Constructor->isImplicit() ? 1 : 0)
7109 << S.Context.getTypeDeclType(Constructor->getParent())
7111 << Entity.getType();
7113 RecordDecl *BaseDecl
7114 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
7116 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
7117 << S.Context.getTagDeclType(BaseDecl);
7119 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
7120 << (Constructor->getInheritedConstructor() ? 2 :
7121 Constructor->isImplicit() ? 1 : 0)
7122 << S.Context.getTypeDeclType(Constructor->getParent())
7124 << Entity.getName();
7125 S.Diag(Entity.getDecl()->getLocation(),
7126 diag::note_member_declared_at);
7128 if (const RecordType *Record
7129 = Entity.getType()->getAs<RecordType>())
7130 S.Diag(Record->getDecl()->getLocation(),
7131 diag::note_previous_decl)
7132 << S.Context.getTagDeclType(Record->getDecl());
7137 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
7138 << DestType << ArgsRange;
7139 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
7143 OverloadCandidateSet::iterator Best;
7144 OverloadingResult Ovl
7145 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7146 if (Ovl != OR_Deleted) {
7147 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7148 << true << DestType << ArgsRange;
7149 llvm_unreachable("Inconsistent overload resolution?");
7153 // If this is a defaulted or implicitly-declared function, then
7154 // it was implicitly deleted. Make it clear that the deletion was
7156 if (S.isImplicitlyDeleted(Best->Function))
7157 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
7158 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
7159 << DestType << ArgsRange;
7161 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
7162 << true << DestType << ArgsRange;
7164 S.NoteDeletedFunction(Best->Function);
7169 llvm_unreachable("Conversion did not fail!");
7174 case FK_DefaultInitOfConst:
7175 if (Entity.getKind() == InitializedEntity::EK_Member &&
7176 isa<CXXConstructorDecl>(S.CurContext)) {
7177 // This is implicit default-initialization of a const member in
7178 // a constructor. Complain that it needs to be explicitly
7180 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
7181 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
7182 << (Constructor->getInheritedConstructor() ? 2 :
7183 Constructor->isImplicit() ? 1 : 0)
7184 << S.Context.getTypeDeclType(Constructor->getParent())
7186 << Entity.getName();
7187 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
7188 << Entity.getName();
7190 S.Diag(Kind.getLocation(), diag::err_default_init_const)
7191 << DestType << (bool)DestType->getAs<RecordType>();
7196 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
7197 diag::err_init_incomplete_type);
7200 case FK_ListInitializationFailed: {
7201 // Run the init list checker again to emit diagnostics.
7202 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
7203 diagnoseListInit(S, Entity, InitList);
7207 case FK_PlaceholderType: {
7208 // FIXME: Already diagnosed!
7212 case FK_ExplicitConstructor: {
7213 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
7214 << Args[0]->getSourceRange();
7215 OverloadCandidateSet::iterator Best;
7216 OverloadingResult Ovl
7217 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
7219 assert(Ovl == OR_Success && "Inconsistent overload resolution");
7220 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
7221 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
7226 PrintInitLocationNote(S, Entity);
7230 void InitializationSequence::dump(raw_ostream &OS) const {
7231 switch (SequenceKind) {
7232 case FailedSequence: {
7233 OS << "Failed sequence: ";
7235 case FK_TooManyInitsForReference:
7236 OS << "too many initializers for reference";
7239 case FK_ArrayNeedsInitList:
7240 OS << "array requires initializer list";
7243 case FK_ArrayNeedsInitListOrStringLiteral:
7244 OS << "array requires initializer list or string literal";
7247 case FK_ArrayNeedsInitListOrWideStringLiteral:
7248 OS << "array requires initializer list or wide string literal";
7251 case FK_NarrowStringIntoWideCharArray:
7252 OS << "narrow string into wide char array";
7255 case FK_WideStringIntoCharArray:
7256 OS << "wide string into char array";
7259 case FK_IncompatWideStringIntoWideChar:
7260 OS << "incompatible wide string into wide char array";
7263 case FK_ArrayTypeMismatch:
7264 OS << "array type mismatch";
7267 case FK_NonConstantArrayInit:
7268 OS << "non-constant array initializer";
7271 case FK_AddressOfOverloadFailed:
7272 OS << "address of overloaded function failed";
7275 case FK_ReferenceInitOverloadFailed:
7276 OS << "overload resolution for reference initialization failed";
7279 case FK_NonConstLValueReferenceBindingToTemporary:
7280 OS << "non-const lvalue reference bound to temporary";
7283 case FK_NonConstLValueReferenceBindingToUnrelated:
7284 OS << "non-const lvalue reference bound to unrelated type";
7287 case FK_RValueReferenceBindingToLValue:
7288 OS << "rvalue reference bound to an lvalue";
7291 case FK_ReferenceInitDropsQualifiers:
7292 OS << "reference initialization drops qualifiers";
7295 case FK_ReferenceInitFailed:
7296 OS << "reference initialization failed";
7299 case FK_ConversionFailed:
7300 OS << "conversion failed";
7303 case FK_ConversionFromPropertyFailed:
7304 OS << "conversion from property failed";
7307 case FK_TooManyInitsForScalar:
7308 OS << "too many initializers for scalar";
7311 case FK_ReferenceBindingToInitList:
7312 OS << "referencing binding to initializer list";
7315 case FK_InitListBadDestinationType:
7316 OS << "initializer list for non-aggregate, non-scalar type";
7319 case FK_UserConversionOverloadFailed:
7320 OS << "overloading failed for user-defined conversion";
7323 case FK_ConstructorOverloadFailed:
7324 OS << "constructor overloading failed";
7327 case FK_DefaultInitOfConst:
7328 OS << "default initialization of a const variable";
7332 OS << "initialization of incomplete type";
7335 case FK_ListInitializationFailed:
7336 OS << "list initialization checker failure";
7339 case FK_VariableLengthArrayHasInitializer:
7340 OS << "variable length array has an initializer";
7343 case FK_PlaceholderType:
7344 OS << "initializer expression isn't contextually valid";
7347 case FK_ListConstructorOverloadFailed:
7348 OS << "list constructor overloading failed";
7351 case FK_ExplicitConstructor:
7352 OS << "list copy initialization chose explicit constructor";
7359 case DependentSequence:
7360 OS << "Dependent sequence\n";
7363 case NormalSequence:
7364 OS << "Normal sequence: ";
7368 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
7369 if (S != step_begin()) {
7374 case SK_ResolveAddressOfOverloadedFunction:
7375 OS << "resolve address of overloaded function";
7378 case SK_CastDerivedToBaseRValue:
7379 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
7382 case SK_CastDerivedToBaseXValue:
7383 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
7386 case SK_CastDerivedToBaseLValue:
7387 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
7390 case SK_BindReference:
7391 OS << "bind reference to lvalue";
7394 case SK_BindReferenceToTemporary:
7395 OS << "bind reference to a temporary";
7398 case SK_ExtraneousCopyToTemporary:
7399 OS << "extraneous C++03 copy to temporary";
7402 case SK_UserConversion:
7403 OS << "user-defined conversion via " << *S->Function.Function;
7406 case SK_QualificationConversionRValue:
7407 OS << "qualification conversion (rvalue)";
7410 case SK_QualificationConversionXValue:
7411 OS << "qualification conversion (xvalue)";
7414 case SK_QualificationConversionLValue:
7415 OS << "qualification conversion (lvalue)";
7418 case SK_AtomicConversion:
7419 OS << "non-atomic-to-atomic conversion";
7422 case SK_LValueToRValue:
7423 OS << "load (lvalue to rvalue)";
7426 case SK_ConversionSequence:
7427 OS << "implicit conversion sequence (";
7428 S->ICS->dump(); // FIXME: use OS
7432 case SK_ConversionSequenceNoNarrowing:
7433 OS << "implicit conversion sequence with narrowing prohibited (";
7434 S->ICS->dump(); // FIXME: use OS
7438 case SK_ListInitialization:
7439 OS << "list aggregate initialization";
7442 case SK_UnwrapInitList:
7443 OS << "unwrap reference initializer list";
7446 case SK_RewrapInitList:
7447 OS << "rewrap reference initializer list";
7450 case SK_ConstructorInitialization:
7451 OS << "constructor initialization";
7454 case SK_ConstructorInitializationFromList:
7455 OS << "list initialization via constructor";
7458 case SK_ZeroInitialization:
7459 OS << "zero initialization";
7462 case SK_CAssignment:
7463 OS << "C assignment";
7467 OS << "string initialization";
7470 case SK_ObjCObjectConversion:
7471 OS << "Objective-C object conversion";
7475 OS << "array initialization";
7478 case SK_ParenthesizedArrayInit:
7479 OS << "parenthesized array initialization";
7482 case SK_PassByIndirectCopyRestore:
7483 OS << "pass by indirect copy and restore";
7486 case SK_PassByIndirectRestore:
7487 OS << "pass by indirect restore";
7490 case SK_ProduceObjCObject:
7491 OS << "Objective-C object retension";
7494 case SK_StdInitializerList:
7495 OS << "std::initializer_list from initializer list";
7498 case SK_StdInitializerListConstructorCall:
7499 OS << "list initialization from std::initializer_list";
7502 case SK_OCLSamplerInit:
7503 OS << "OpenCL sampler_t from integer constant";
7506 case SK_OCLZeroEvent:
7507 OS << "OpenCL event_t from zero";
7511 OS << " [" << S->Type.getAsString() << ']';
7517 void InitializationSequence::dump() const {
7521 static void DiagnoseNarrowingInInitList(Sema &S,
7522 const ImplicitConversionSequence &ICS,
7523 QualType PreNarrowingType,
7524 QualType EntityType,
7525 const Expr *PostInit) {
7526 const StandardConversionSequence *SCS = nullptr;
7527 switch (ICS.getKind()) {
7528 case ImplicitConversionSequence::StandardConversion:
7529 SCS = &ICS.Standard;
7531 case ImplicitConversionSequence::UserDefinedConversion:
7532 SCS = &ICS.UserDefined.After;
7534 case ImplicitConversionSequence::AmbiguousConversion:
7535 case ImplicitConversionSequence::EllipsisConversion:
7536 case ImplicitConversionSequence::BadConversion:
7540 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
7541 APValue ConstantValue;
7542 QualType ConstantType;
7543 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7545 case NK_Not_Narrowing:
7546 // No narrowing occurred.
7549 case NK_Type_Narrowing:
7550 // This was a floating-to-integer conversion, which is always considered a
7551 // narrowing conversion even if the value is a constant and can be
7552 // represented exactly as an integer.
7553 S.Diag(PostInit->getLocStart(),
7554 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7555 ? diag::warn_init_list_type_narrowing
7556 : diag::ext_init_list_type_narrowing)
7557 << PostInit->getSourceRange()
7558 << PreNarrowingType.getLocalUnqualifiedType()
7559 << EntityType.getLocalUnqualifiedType();
7562 case NK_Constant_Narrowing:
7563 // A constant value was narrowed.
7564 S.Diag(PostInit->getLocStart(),
7565 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7566 ? diag::warn_init_list_constant_narrowing
7567 : diag::ext_init_list_constant_narrowing)
7568 << PostInit->getSourceRange()
7569 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
7570 << EntityType.getLocalUnqualifiedType();
7573 case NK_Variable_Narrowing:
7574 // A variable's value may have been narrowed.
7575 S.Diag(PostInit->getLocStart(),
7576 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7577 ? diag::warn_init_list_variable_narrowing
7578 : diag::ext_init_list_variable_narrowing)
7579 << PostInit->getSourceRange()
7580 << PreNarrowingType.getLocalUnqualifiedType()
7581 << EntityType.getLocalUnqualifiedType();
7585 SmallString<128> StaticCast;
7586 llvm::raw_svector_ostream OS(StaticCast);
7587 OS << "static_cast<";
7588 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7589 // It's important to use the typedef's name if there is one so that the
7590 // fixit doesn't break code using types like int64_t.
7592 // FIXME: This will break if the typedef requires qualification. But
7593 // getQualifiedNameAsString() includes non-machine-parsable components.
7594 OS << *TT->getDecl();
7595 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
7596 OS << BT->getName(S.getLangOpts());
7598 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7599 // with a broken cast.
7603 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence)
7604 << PostInit->getSourceRange()
7605 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7606 << FixItHint::CreateInsertion(
7607 S.getLocForEndOfToken(PostInit->getLocEnd()), ")");
7610 //===----------------------------------------------------------------------===//
7611 // Initialization helper functions
7612 //===----------------------------------------------------------------------===//
7614 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7616 if (Init.isInvalid())
7619 Expr *InitE = Init.get();
7620 assert(InitE && "No initialization expression");
7622 InitializationKind Kind
7623 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
7624 InitializationSequence Seq(*this, Entity, Kind, InitE);
7625 return !Seq.Failed();
7629 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7630 SourceLocation EqualLoc,
7632 bool TopLevelOfInitList,
7633 bool AllowExplicit) {
7634 if (Init.isInvalid())
7637 Expr *InitE = Init.get();
7638 assert(InitE && "No initialization expression?");
7640 if (EqualLoc.isInvalid())
7641 EqualLoc = InitE->getLocStart();
7643 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
7646 InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
7648 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);