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/Lex/Preprocessor.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.
153 cast<ConstantArrayType>(Str->getType())->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::warn_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 void UpdateStructuredListElement(InitListExpr *StructuredList,
311 unsigned &StructuredIndex,
313 int numArrayElements(QualType DeclType);
314 int numStructUnionElements(QualType DeclType);
316 void FillInValueInitForField(unsigned Init, FieldDecl *Field,
317 const InitializedEntity &ParentEntity,
318 InitListExpr *ILE, bool &RequiresSecondPass);
319 void FillInValueInitializations(const InitializedEntity &Entity,
320 InitListExpr *ILE, bool &RequiresSecondPass);
321 bool CheckFlexibleArrayInit(const InitializedEntity &Entity,
322 Expr *InitExpr, FieldDecl *Field,
323 bool TopLevelObject);
324 void CheckValueInitializable(const InitializedEntity &Entity);
327 InitListChecker(Sema &S, const InitializedEntity &Entity,
328 InitListExpr *IL, QualType &T, bool VerifyOnly);
329 bool HadError() { return hadError; }
331 // @brief Retrieves the fully-structured initializer list used for
332 // semantic analysis and code generation.
333 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
335 } // end anonymous namespace
337 void InitListChecker::CheckValueInitializable(const InitializedEntity &Entity) {
339 "CheckValueInitializable is only inteded for verification mode.");
342 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
344 InitializationSequence InitSeq(SemaRef, Entity, Kind, None);
345 if (InitSeq.Failed())
349 void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field,
350 const InitializedEntity &ParentEntity,
352 bool &RequiresSecondPass) {
353 SourceLocation Loc = ILE->getLocStart();
354 unsigned NumInits = ILE->getNumInits();
355 InitializedEntity MemberEntity
356 = InitializedEntity::InitializeMember(Field, &ParentEntity);
357 if (Init >= NumInits || !ILE->getInit(Init)) {
358 // If there's no explicit initializer but we have a default initializer, use
359 // that. This only happens in C++1y, since classes with default
360 // initializers are not aggregates in C++11.
361 if (Field->hasInClassInitializer()) {
362 Expr *DIE = CXXDefaultInitExpr::Create(SemaRef.Context,
363 ILE->getRBraceLoc(), Field);
365 ILE->setInit(Init, DIE);
367 ILE->updateInit(SemaRef.Context, Init, DIE);
368 RequiresSecondPass = true;
373 // FIXME: We probably don't need to handle references
374 // specially here, since value-initialization of references is
375 // handled in InitializationSequence.
376 if (Field->getType()->isReferenceType()) {
377 // C++ [dcl.init.aggr]p9:
378 // If an incomplete or empty initializer-list leaves a
379 // member of reference type uninitialized, the program is
381 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
383 << ILE->getSyntacticForm()->getSourceRange();
384 SemaRef.Diag(Field->getLocation(),
385 diag::note_uninit_reference_member);
390 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
392 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, None);
394 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, None);
399 ExprResult MemberInit
400 = InitSeq.Perform(SemaRef, MemberEntity, Kind, None);
401 if (MemberInit.isInvalid()) {
408 } else if (Init < NumInits) {
409 ILE->setInit(Init, MemberInit.takeAs<Expr>());
410 } else if (InitSeq.isConstructorInitialization()) {
411 // Value-initialization requires a constructor call, so
412 // extend the initializer list to include the constructor
413 // call and make a note that we'll need to take another pass
414 // through the initializer list.
415 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>());
416 RequiresSecondPass = true;
418 } else if (InitListExpr *InnerILE
419 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
420 FillInValueInitializations(MemberEntity, InnerILE,
424 /// Recursively replaces NULL values within the given initializer list
425 /// with expressions that perform value-initialization of the
426 /// appropriate type.
428 InitListChecker::FillInValueInitializations(const InitializedEntity &Entity,
430 bool &RequiresSecondPass) {
431 assert((ILE->getType() != SemaRef.Context.VoidTy) &&
432 "Should not have void type");
433 SourceLocation Loc = ILE->getLocStart();
434 if (ILE->getSyntacticForm())
435 Loc = ILE->getSyntacticForm()->getLocStart();
437 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
438 const RecordDecl *RDecl = RType->getDecl();
439 if (RDecl->isUnion() && ILE->getInitializedFieldInUnion())
440 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(),
441 Entity, ILE, RequiresSecondPass);
442 else if (RDecl->isUnion() && isa<CXXRecordDecl>(RDecl) &&
443 cast<CXXRecordDecl>(RDecl)->hasInClassInitializer()) {
444 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
445 FieldEnd = RDecl->field_end();
446 Field != FieldEnd; ++Field) {
447 if (Field->hasInClassInitializer()) {
448 FillInValueInitForField(0, *Field, Entity, ILE, RequiresSecondPass);
454 for (RecordDecl::field_iterator Field = RDecl->field_begin(),
455 FieldEnd = RDecl->field_end();
456 Field != FieldEnd; ++Field) {
457 if (Field->isUnnamedBitfield())
463 FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass);
469 // Only look at the first initialization of a union.
470 if (RDecl->isUnion())
478 QualType ElementType;
480 InitializedEntity ElementEntity = Entity;
481 unsigned NumInits = ILE->getNumInits();
482 unsigned NumElements = NumInits;
483 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
484 ElementType = AType->getElementType();
485 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
486 NumElements = CAType->getSize().getZExtValue();
487 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
489 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) {
490 ElementType = VType->getElementType();
491 NumElements = VType->getNumElements();
492 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context,
495 ElementType = ILE->getType();
498 for (unsigned Init = 0; Init != NumElements; ++Init) {
502 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement ||
503 ElementEntity.getKind() == InitializedEntity::EK_VectorElement)
504 ElementEntity.setElementIndex(Init);
506 Expr *InitExpr = (Init < NumInits ? ILE->getInit(Init) : 0);
507 if (!InitExpr && !ILE->hasArrayFiller()) {
508 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc,
510 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, None);
512 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, None);
517 ExprResult ElementInit
518 = InitSeq.Perform(SemaRef, ElementEntity, Kind, None);
519 if (ElementInit.isInvalid()) {
526 } else if (Init < NumInits) {
527 // For arrays, just set the expression used for value-initialization
528 // of the "holes" in the array.
529 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement)
530 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
532 ILE->setInit(Init, ElementInit.takeAs<Expr>());
534 // For arrays, just set the expression used for value-initialization
535 // of the rest of elements and exit.
536 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement) {
537 ILE->setArrayFiller(ElementInit.takeAs<Expr>());
541 if (InitSeq.isConstructorInitialization()) {
542 // Value-initialization requires a constructor call, so
543 // extend the initializer list to include the constructor
544 // call and make a note that we'll need to take another pass
545 // through the initializer list.
546 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>());
547 RequiresSecondPass = true;
550 } else if (InitListExpr *InnerILE
551 = dyn_cast_or_null<InitListExpr>(InitExpr))
552 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass);
557 InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity,
558 InitListExpr *IL, QualType &T,
560 : SemaRef(S), VerifyOnly(VerifyOnly) {
563 FullyStructuredList =
564 getStructuredSubobjectInit(IL, 0, T, 0, 0, IL->getSourceRange());
565 CheckExplicitInitList(Entity, IL, T, FullyStructuredList,
566 /*TopLevelObject=*/true);
568 if (!hadError && !VerifyOnly) {
569 bool RequiresSecondPass = false;
570 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass);
571 if (RequiresSecondPass && !hadError)
572 FillInValueInitializations(Entity, FullyStructuredList,
577 int InitListChecker::numArrayElements(QualType DeclType) {
578 // FIXME: use a proper constant
579 int maxElements = 0x7FFFFFFF;
580 if (const ConstantArrayType *CAT =
581 SemaRef.Context.getAsConstantArrayType(DeclType)) {
582 maxElements = static_cast<int>(CAT->getSize().getZExtValue());
587 int InitListChecker::numStructUnionElements(QualType DeclType) {
588 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
589 int InitializableMembers = 0;
590 for (RecordDecl::field_iterator
591 Field = structDecl->field_begin(),
592 FieldEnd = structDecl->field_end();
593 Field != FieldEnd; ++Field) {
594 if (!Field->isUnnamedBitfield())
595 ++InitializableMembers;
597 if (structDecl->isUnion())
598 return std::min(InitializableMembers, 1);
599 return InitializableMembers - structDecl->hasFlexibleArrayMember();
602 /// Check whether the range of the initializer \p ParentIList from element
603 /// \p Index onwards can be used to initialize an object of type \p T. Update
604 /// \p Index to indicate how many elements of the list were consumed.
606 /// This also fills in \p StructuredList, from element \p StructuredIndex
607 /// onwards, with the fully-braced, desugared form of the initialization.
608 void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity,
609 InitListExpr *ParentIList,
610 QualType T, unsigned &Index,
611 InitListExpr *StructuredList,
612 unsigned &StructuredIndex) {
615 if (T->isArrayType())
616 maxElements = numArrayElements(T);
617 else if (T->isRecordType())
618 maxElements = numStructUnionElements(T);
619 else if (T->isVectorType())
620 maxElements = T->getAs<VectorType>()->getNumElements();
622 llvm_unreachable("CheckImplicitInitList(): Illegal type");
624 if (maxElements == 0) {
626 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
627 diag::err_implicit_empty_initializer);
633 // Build a structured initializer list corresponding to this subobject.
634 InitListExpr *StructuredSubobjectInitList
635 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
637 SourceRange(ParentIList->getInit(Index)->getLocStart(),
638 ParentIList->getSourceRange().getEnd()));
639 unsigned StructuredSubobjectInitIndex = 0;
641 // Check the element types and build the structural subobject.
642 unsigned StartIndex = Index;
643 CheckListElementTypes(Entity, ParentIList, T,
644 /*SubobjectIsDesignatorContext=*/false, Index,
645 StructuredSubobjectInitList,
646 StructuredSubobjectInitIndex);
649 StructuredSubobjectInitList->setType(T);
651 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
652 // Update the structured sub-object initializer so that it's ending
653 // range corresponds with the end of the last initializer it used.
654 if (EndIndex < ParentIList->getNumInits()) {
655 SourceLocation EndLoc
656 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
657 StructuredSubobjectInitList->setRBraceLoc(EndLoc);
660 // Complain about missing braces.
661 if (T->isArrayType() || T->isRecordType()) {
662 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(),
663 diag::warn_missing_braces)
664 << StructuredSubobjectInitList->getSourceRange()
665 << FixItHint::CreateInsertion(
666 StructuredSubobjectInitList->getLocStart(), "{")
667 << FixItHint::CreateInsertion(
668 SemaRef.PP.getLocForEndOfToken(
669 StructuredSubobjectInitList->getLocEnd()),
675 /// Check whether the initializer \p IList (that was written with explicit
676 /// braces) can be used to initialize an object of type \p T.
678 /// This also fills in \p StructuredList with the fully-braced, desugared
679 /// form of the initialization.
680 void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity,
681 InitListExpr *IList, QualType &T,
682 InitListExpr *StructuredList,
683 bool TopLevelObject) {
684 assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
686 SyntacticToSemantic[IList] = StructuredList;
687 StructuredList->setSyntacticForm(IList);
690 unsigned Index = 0, StructuredIndex = 0;
691 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true,
692 Index, StructuredList, StructuredIndex, TopLevelObject);
695 if (!ExprTy->isArrayType())
696 ExprTy = ExprTy.getNonLValueExprType(SemaRef.Context);
697 IList->setType(ExprTy);
698 StructuredList->setType(ExprTy);
703 if (Index < IList->getNumInits()) {
704 // We have leftover initializers
706 if (SemaRef.getLangOpts().CPlusPlus ||
707 (SemaRef.getLangOpts().OpenCL &&
708 IList->getType()->isVectorType())) {
714 if (StructuredIndex == 1 &&
715 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context) ==
717 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
718 if (SemaRef.getLangOpts().CPlusPlus) {
719 DK = diag::err_excess_initializers_in_char_array_initializer;
723 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
724 << IList->getInit(Index)->getSourceRange();
725 } else if (!T->isIncompleteType()) {
726 // Don't complain for incomplete types, since we'll get an error
728 QualType CurrentObjectType = StructuredList->getType();
730 CurrentObjectType->isArrayType()? 0 :
731 CurrentObjectType->isVectorType()? 1 :
732 CurrentObjectType->isScalarType()? 2 :
733 CurrentObjectType->isUnionType()? 3 :
736 unsigned DK = diag::warn_excess_initializers;
737 if (SemaRef.getLangOpts().CPlusPlus) {
738 DK = diag::err_excess_initializers;
741 if (SemaRef.getLangOpts().OpenCL && initKind == 1) {
742 DK = diag::err_excess_initializers;
746 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
747 << initKind << IList->getInit(Index)->getSourceRange();
751 if (!VerifyOnly && T->isScalarType() && IList->getNumInits() == 1 &&
753 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
754 << IList->getSourceRange()
755 << FixItHint::CreateRemoval(IList->getLocStart())
756 << FixItHint::CreateRemoval(IList->getLocEnd());
759 void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity,
762 bool SubobjectIsDesignatorContext,
764 InitListExpr *StructuredList,
765 unsigned &StructuredIndex,
766 bool TopLevelObject) {
767 if (DeclType->isAnyComplexType() && SubobjectIsDesignatorContext) {
768 // Explicitly braced initializer for complex type can be real+imaginary
770 CheckComplexType(Entity, IList, DeclType, Index,
771 StructuredList, StructuredIndex);
772 } else if (DeclType->isScalarType()) {
773 CheckScalarType(Entity, IList, DeclType, Index,
774 StructuredList, StructuredIndex);
775 } else if (DeclType->isVectorType()) {
776 CheckVectorType(Entity, IList, DeclType, Index,
777 StructuredList, StructuredIndex);
778 } else if (DeclType->isRecordType()) {
779 assert(DeclType->isAggregateType() &&
780 "non-aggregate records should be handed in CheckSubElementType");
781 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
782 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(),
783 SubobjectIsDesignatorContext, Index,
784 StructuredList, StructuredIndex,
786 } else if (DeclType->isArrayType()) {
788 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
790 CheckArrayType(Entity, IList, DeclType, Zero,
791 SubobjectIsDesignatorContext, Index,
792 StructuredList, StructuredIndex);
793 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) {
794 // This type is invalid, issue a diagnostic.
797 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
800 } else if (DeclType->isReferenceType()) {
801 CheckReferenceType(Entity, IList, DeclType, Index,
802 StructuredList, StructuredIndex);
803 } else if (DeclType->isObjCObjectType()) {
805 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class)
810 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
816 void InitListChecker::CheckSubElementType(const InitializedEntity &Entity,
820 InitListExpr *StructuredList,
821 unsigned &StructuredIndex) {
822 Expr *expr = IList->getInit(Index);
824 if (ElemType->isReferenceType())
825 return CheckReferenceType(Entity, IList, ElemType, Index,
826 StructuredList, StructuredIndex);
828 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) {
829 if (!ElemType->isRecordType() || ElemType->isAggregateType()) {
830 InitListExpr *InnerStructuredList
831 = getStructuredSubobjectInit(IList, Index, ElemType,
832 StructuredList, StructuredIndex,
833 SubInitList->getSourceRange());
834 CheckExplicitInitList(Entity, SubInitList, ElemType,
835 InnerStructuredList);
840 assert(SemaRef.getLangOpts().CPlusPlus &&
841 "non-aggregate records are only possible in C++");
842 // C++ initialization is handled later.
845 // FIXME: Need to handle atomic aggregate types with implicit init lists.
846 if (ElemType->isScalarType() || ElemType->isAtomicType())
847 return CheckScalarType(Entity, IList, ElemType, Index,
848 StructuredList, StructuredIndex);
850 assert((ElemType->isRecordType() || ElemType->isVectorType() ||
851 ElemType->isArrayType()) && "Unexpected type");
853 if (const ArrayType *arrayType = SemaRef.Context.getAsArrayType(ElemType)) {
854 // arrayType can be incomplete if we're initializing a flexible
855 // array member. There's nothing we can do with the completed
856 // type here, though.
858 if (IsStringInit(expr, arrayType, SemaRef.Context) == SIF_None) {
860 CheckStringInit(expr, ElemType, arrayType, SemaRef);
861 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
867 // Fall through for subaggregate initialization.
869 } else if (SemaRef.getLangOpts().CPlusPlus) {
870 // C++ [dcl.init.aggr]p12:
871 // All implicit type conversions (clause 4) are considered when
872 // initializing the aggregate member with an initializer from
873 // an initializer-list. If the initializer can initialize a
874 // member, the member is initialized. [...]
876 // FIXME: Better EqualLoc?
877 InitializationKind Kind =
878 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation());
879 InitializationSequence Seq(SemaRef, Entity, Kind, expr);
884 Seq.Perform(SemaRef, Entity, Kind, expr);
885 if (Result.isInvalid())
888 UpdateStructuredListElement(StructuredList, StructuredIndex,
889 Result.takeAs<Expr>());
895 // Fall through for subaggregate initialization
899 // The initializer for a structure or union object that has
900 // automatic storage duration shall be either an initializer
901 // list as described below, or a single expression that has
902 // compatible structure or union type. In the latter case, the
903 // initial value of the object, including unnamed members, is
904 // that of the expression.
905 ExprResult ExprRes = SemaRef.Owned(expr);
906 if ((ElemType->isRecordType() || ElemType->isVectorType()) &&
907 SemaRef.CheckSingleAssignmentConstraints(ElemType, ExprRes,
909 != Sema::Incompatible) {
910 if (ExprRes.isInvalid())
913 ExprRes = SemaRef.DefaultFunctionArrayLvalueConversion(ExprRes.take());
914 if (ExprRes.isInvalid())
917 UpdateStructuredListElement(StructuredList, StructuredIndex,
918 ExprRes.takeAs<Expr>());
923 // Fall through for subaggregate initialization
926 // C++ [dcl.init.aggr]p12:
928 // [...] Otherwise, if the member is itself a non-empty
929 // subaggregate, brace elision is assumed and the initializer is
930 // considered for the initialization of the first member of
932 if (!SemaRef.getLangOpts().OpenCL &&
933 (ElemType->isAggregateType() || ElemType->isVectorType())) {
934 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList,
939 // We cannot initialize this element, so let
940 // PerformCopyInitialization produce the appropriate diagnostic.
941 SemaRef.PerformCopyInitialization(Entity, SourceLocation(),
943 /*TopLevelOfInitList=*/true);
951 void InitListChecker::CheckComplexType(const InitializedEntity &Entity,
952 InitListExpr *IList, QualType DeclType,
954 InitListExpr *StructuredList,
955 unsigned &StructuredIndex) {
956 assert(Index == 0 && "Index in explicit init list must be zero");
958 // As an extension, clang supports complex initializers, which initialize
959 // a complex number component-wise. When an explicit initializer list for
960 // a complex number contains two two initializers, this extension kicks in:
961 // it exepcts the initializer list to contain two elements convertible to
962 // the element type of the complex type. The first element initializes
963 // the real part, and the second element intitializes the imaginary part.
965 if (IList->getNumInits() != 2)
966 return CheckScalarType(Entity, IList, DeclType, Index, StructuredList,
969 // This is an extension in C. (The builtin _Complex type does not exist
970 // in the C++ standard.)
971 if (!SemaRef.getLangOpts().CPlusPlus && !VerifyOnly)
972 SemaRef.Diag(IList->getLocStart(), diag::ext_complex_component_init)
973 << IList->getSourceRange();
975 // Initialize the complex number.
976 QualType elementType = DeclType->getAs<ComplexType>()->getElementType();
977 InitializedEntity ElementEntity =
978 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
980 for (unsigned i = 0; i < 2; ++i) {
981 ElementEntity.setElementIndex(Index);
982 CheckSubElementType(ElementEntity, IList, elementType, Index,
983 StructuredList, StructuredIndex);
988 void InitListChecker::CheckScalarType(const InitializedEntity &Entity,
989 InitListExpr *IList, QualType DeclType,
991 InitListExpr *StructuredList,
992 unsigned &StructuredIndex) {
993 if (Index >= IList->getNumInits()) {
995 SemaRef.Diag(IList->getLocStart(),
996 SemaRef.getLangOpts().CPlusPlus11 ?
997 diag::warn_cxx98_compat_empty_scalar_initializer :
998 diag::err_empty_scalar_initializer)
999 << IList->getSourceRange();
1000 hadError = !SemaRef.getLangOpts().CPlusPlus11;
1006 Expr *expr = IList->getInit(Index);
1007 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {
1009 SemaRef.Diag(SubIList->getLocStart(),
1010 diag::warn_many_braces_around_scalar_init)
1011 << SubIList->getSourceRange();
1013 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList,
1016 } else if (isa<DesignatedInitExpr>(expr)) {
1018 SemaRef.Diag(expr->getLocStart(),
1019 diag::err_designator_for_scalar_init)
1020 << DeclType << expr->getSourceRange();
1028 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1035 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1036 SemaRef.Owned(expr),
1037 /*TopLevelOfInitList=*/true);
1039 Expr *ResultExpr = 0;
1041 if (Result.isInvalid())
1042 hadError = true; // types weren't compatible.
1044 ResultExpr = Result.takeAs<Expr>();
1046 if (ResultExpr != expr) {
1047 // The type was promoted, update initializer list.
1048 IList->setInit(Index, ResultExpr);
1054 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr);
1058 void InitListChecker::CheckReferenceType(const InitializedEntity &Entity,
1059 InitListExpr *IList, QualType DeclType,
1061 InitListExpr *StructuredList,
1062 unsigned &StructuredIndex) {
1063 if (Index >= IList->getNumInits()) {
1064 // FIXME: It would be wonderful if we could point at the actual member. In
1065 // general, it would be useful to pass location information down the stack,
1066 // so that we know the location (or decl) of the "current object" being
1069 SemaRef.Diag(IList->getLocStart(),
1070 diag::err_init_reference_member_uninitialized)
1072 << IList->getSourceRange();
1079 Expr *expr = IList->getInit(Index);
1080 if (isa<InitListExpr>(expr) && !SemaRef.getLangOpts().CPlusPlus11) {
1082 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list)
1083 << DeclType << IList->getSourceRange();
1091 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(expr)))
1098 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(),
1099 SemaRef.Owned(expr),
1100 /*TopLevelOfInitList=*/true);
1102 if (Result.isInvalid())
1105 expr = Result.takeAs<Expr>();
1106 IList->setInit(Index, expr);
1111 UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
1115 void InitListChecker::CheckVectorType(const InitializedEntity &Entity,
1116 InitListExpr *IList, QualType DeclType,
1118 InitListExpr *StructuredList,
1119 unsigned &StructuredIndex) {
1120 const VectorType *VT = DeclType->getAs<VectorType>();
1121 unsigned maxElements = VT->getNumElements();
1122 unsigned numEltsInit = 0;
1123 QualType elementType = VT->getElementType();
1125 if (Index >= IList->getNumInits()) {
1126 // Make sure the element type can be value-initialized.
1128 CheckValueInitializable(
1129 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity));
1133 if (!SemaRef.getLangOpts().OpenCL) {
1134 // If the initializing element is a vector, try to copy-initialize
1135 // instead of breaking it apart (which is doomed to failure anyway).
1136 Expr *Init = IList->getInit(Index);
1137 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) {
1139 if (!SemaRef.CanPerformCopyInitialization(Entity, SemaRef.Owned(Init)))
1146 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(),
1147 SemaRef.Owned(Init),
1148 /*TopLevelOfInitList=*/true);
1150 Expr *ResultExpr = 0;
1151 if (Result.isInvalid())
1152 hadError = true; // types weren't compatible.
1154 ResultExpr = Result.takeAs<Expr>();
1156 if (ResultExpr != Init) {
1157 // The type was promoted, update initializer list.
1158 IList->setInit(Index, ResultExpr);
1164 UpdateStructuredListElement(StructuredList, StructuredIndex,
1170 InitializedEntity ElementEntity =
1171 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1173 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) {
1174 // Don't attempt to go past the end of the init list
1175 if (Index >= IList->getNumInits()) {
1177 CheckValueInitializable(ElementEntity);
1181 ElementEntity.setElementIndex(Index);
1182 CheckSubElementType(ElementEntity, IList, elementType, Index,
1183 StructuredList, StructuredIndex);
1188 InitializedEntity ElementEntity =
1189 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
1191 // OpenCL initializers allows vectors to be constructed from vectors.
1192 for (unsigned i = 0; i < maxElements; ++i) {
1193 // Don't attempt to go past the end of the init list
1194 if (Index >= IList->getNumInits())
1197 ElementEntity.setElementIndex(Index);
1199 QualType IType = IList->getInit(Index)->getType();
1200 if (!IType->isVectorType()) {
1201 CheckSubElementType(ElementEntity, IList, elementType, Index,
1202 StructuredList, StructuredIndex);
1206 const VectorType *IVT = IType->getAs<VectorType>();
1207 unsigned numIElts = IVT->getNumElements();
1209 if (IType->isExtVectorType())
1210 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts);
1212 VecType = SemaRef.Context.getVectorType(elementType, numIElts,
1213 IVT->getVectorKind());
1214 CheckSubElementType(ElementEntity, IList, VecType, Index,
1215 StructuredList, StructuredIndex);
1216 numEltsInit += numIElts;
1220 // OpenCL requires all elements to be initialized.
1221 if (numEltsInit != maxElements) {
1223 SemaRef.Diag(IList->getLocStart(),
1224 diag::err_vector_incorrect_num_initializers)
1225 << (numEltsInit < maxElements) << maxElements << numEltsInit;
1230 void InitListChecker::CheckArrayType(const InitializedEntity &Entity,
1231 InitListExpr *IList, QualType &DeclType,
1232 llvm::APSInt elementIndex,
1233 bool SubobjectIsDesignatorContext,
1235 InitListExpr *StructuredList,
1236 unsigned &StructuredIndex) {
1237 const ArrayType *arrayType = SemaRef.Context.getAsArrayType(DeclType);
1239 // Check for the special-case of initializing an array with a string.
1240 if (Index < IList->getNumInits()) {
1241 if (IsStringInit(IList->getInit(Index), arrayType, SemaRef.Context) ==
1243 // We place the string literal directly into the resulting
1244 // initializer list. This is the only place where the structure
1245 // of the structured initializer list doesn't match exactly,
1246 // because doing so would involve allocating one character
1247 // constant for each string.
1249 CheckStringInit(IList->getInit(Index), DeclType, arrayType, SemaRef);
1250 UpdateStructuredListElement(StructuredList, StructuredIndex,
1251 IList->getInit(Index));
1252 StructuredList->resizeInits(SemaRef.Context, StructuredIndex);
1258 if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {
1259 // Check for VLAs; in standard C it would be possible to check this
1260 // earlier, but I don't know where clang accepts VLAs (gcc accepts
1261 // them in all sorts of strange places).
1263 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(),
1264 diag::err_variable_object_no_init)
1265 << VAT->getSizeExpr()->getSourceRange();
1272 // We might know the maximum number of elements in advance.
1273 llvm::APSInt maxElements(elementIndex.getBitWidth(),
1274 elementIndex.isUnsigned());
1275 bool maxElementsKnown = false;
1276 if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(arrayType)) {
1277 maxElements = CAT->getSize();
1278 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth());
1279 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1280 maxElementsKnown = true;
1283 QualType elementType = arrayType->getElementType();
1284 while (Index < IList->getNumInits()) {
1285 Expr *Init = IList->getInit(Index);
1286 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1287 // If we're not the subobject that matches up with the '{' for
1288 // the designator, we shouldn't be handling the
1289 // designator. Return immediately.
1290 if (!SubobjectIsDesignatorContext)
1293 // Handle this designated initializer. elementIndex will be
1294 // updated to be the next array element we'll initialize.
1295 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1296 DeclType, 0, &elementIndex, Index,
1297 StructuredList, StructuredIndex, true,
1303 if (elementIndex.getBitWidth() > maxElements.getBitWidth())
1304 maxElements = maxElements.extend(elementIndex.getBitWidth());
1305 else if (elementIndex.getBitWidth() < maxElements.getBitWidth())
1306 elementIndex = elementIndex.extend(maxElements.getBitWidth());
1307 elementIndex.setIsUnsigned(maxElements.isUnsigned());
1309 // If the array is of incomplete type, keep track of the number of
1310 // elements in the initializer.
1311 if (!maxElementsKnown && elementIndex > maxElements)
1312 maxElements = elementIndex;
1317 // If we know the maximum number of elements, and we've already
1318 // hit it, stop consuming elements in the initializer list.
1319 if (maxElementsKnown && elementIndex == maxElements)
1322 InitializedEntity ElementEntity =
1323 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex,
1325 // Check this element.
1326 CheckSubElementType(ElementEntity, IList, elementType, Index,
1327 StructuredList, StructuredIndex);
1330 // If the array is of incomplete type, keep track of the number of
1331 // elements in the initializer.
1332 if (!maxElementsKnown && elementIndex > maxElements)
1333 maxElements = elementIndex;
1335 if (!hadError && DeclType->isIncompleteArrayType() && !VerifyOnly) {
1336 // If this is an incomplete array type, the actual type needs to
1337 // be calculated here.
1338 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned());
1339 if (maxElements == Zero) {
1340 // Sizing an array implicitly to zero is not allowed by ISO C,
1341 // but is supported by GNU.
1342 SemaRef.Diag(IList->getLocStart(),
1343 diag::ext_typecheck_zero_array_size);
1346 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
1347 ArrayType::Normal, 0);
1349 if (!hadError && VerifyOnly) {
1350 // Check if there are any members of the array that get value-initialized.
1351 // If so, check if doing that is possible.
1352 // FIXME: This needs to detect holes left by designated initializers too.
1353 if (maxElementsKnown && elementIndex < maxElements)
1354 CheckValueInitializable(InitializedEntity::InitializeElement(
1355 SemaRef.Context, 0, Entity));
1359 bool InitListChecker::CheckFlexibleArrayInit(const InitializedEntity &Entity,
1362 bool TopLevelObject) {
1363 // Handle GNU flexible array initializers.
1364 unsigned FlexArrayDiag;
1365 if (isa<InitListExpr>(InitExpr) &&
1366 cast<InitListExpr>(InitExpr)->getNumInits() == 0) {
1367 // Empty flexible array init always allowed as an extension
1368 FlexArrayDiag = diag::ext_flexible_array_init;
1369 } else if (SemaRef.getLangOpts().CPlusPlus) {
1370 // Disallow flexible array init in C++; it is not required for gcc
1371 // compatibility, and it needs work to IRGen correctly in general.
1372 FlexArrayDiag = diag::err_flexible_array_init;
1373 } else if (!TopLevelObject) {
1374 // Disallow flexible array init on non-top-level object
1375 FlexArrayDiag = diag::err_flexible_array_init;
1376 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
1377 // Disallow flexible array init on anything which is not a variable.
1378 FlexArrayDiag = diag::err_flexible_array_init;
1379 } else if (cast<VarDecl>(Entity.getDecl())->hasLocalStorage()) {
1380 // Disallow flexible array init on local variables.
1381 FlexArrayDiag = diag::err_flexible_array_init;
1383 // Allow other cases.
1384 FlexArrayDiag = diag::ext_flexible_array_init;
1388 SemaRef.Diag(InitExpr->getLocStart(),
1390 << InitExpr->getLocStart();
1391 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1395 return FlexArrayDiag != diag::ext_flexible_array_init;
1398 void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity,
1399 InitListExpr *IList,
1401 RecordDecl::field_iterator Field,
1402 bool SubobjectIsDesignatorContext,
1404 InitListExpr *StructuredList,
1405 unsigned &StructuredIndex,
1406 bool TopLevelObject) {
1407 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
1409 // If the record is invalid, some of it's members are invalid. To avoid
1410 // confusion, we forgo checking the intializer for the entire record.
1411 if (structDecl->isInvalidDecl()) {
1412 // Assume it was supposed to consume a single initializer.
1418 if (DeclType->isUnionType() && IList->getNumInits() == 0) {
1419 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1421 // If there's a default initializer, use it.
1422 if (isa<CXXRecordDecl>(RD) && cast<CXXRecordDecl>(RD)->hasInClassInitializer()) {
1425 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1426 Field != FieldEnd; ++Field) {
1427 if (Field->hasInClassInitializer()) {
1428 StructuredList->setInitializedFieldInUnion(*Field);
1429 // FIXME: Actually build a CXXDefaultInitExpr?
1435 // Value-initialize the first named member of the union.
1436 for (RecordDecl::field_iterator FieldEnd = RD->field_end();
1437 Field != FieldEnd; ++Field) {
1438 if (Field->getDeclName()) {
1440 CheckValueInitializable(
1441 InitializedEntity::InitializeMember(*Field, &Entity));
1443 StructuredList->setInitializedFieldInUnion(*Field);
1450 // If structDecl is a forward declaration, this loop won't do
1451 // anything except look at designated initializers; That's okay,
1452 // because an error should get printed out elsewhere. It might be
1453 // worthwhile to skip over the rest of the initializer, though.
1454 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
1455 RecordDecl::field_iterator FieldEnd = RD->field_end();
1456 bool InitializedSomething = false;
1457 bool CheckForMissingFields = true;
1458 while (Index < IList->getNumInits()) {
1459 Expr *Init = IList->getInit(Index);
1461 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) {
1462 // If we're not the subobject that matches up with the '{' for
1463 // the designator, we shouldn't be handling the
1464 // designator. Return immediately.
1465 if (!SubobjectIsDesignatorContext)
1468 // Handle this designated initializer. Field will be updated to
1469 // the next field that we'll be initializing.
1470 if (CheckDesignatedInitializer(Entity, IList, DIE, 0,
1471 DeclType, &Field, 0, Index,
1472 StructuredList, StructuredIndex,
1473 true, TopLevelObject))
1476 InitializedSomething = true;
1478 // Disable check for missing fields when designators are used.
1479 // This matches gcc behaviour.
1480 CheckForMissingFields = false;
1484 if (Field == FieldEnd) {
1485 // We've run out of fields. We're done.
1489 // We've already initialized a member of a union. We're done.
1490 if (InitializedSomething && DeclType->isUnionType())
1493 // If we've hit the flexible array member at the end, we're done.
1494 if (Field->getType()->isIncompleteArrayType())
1497 if (Field->isUnnamedBitfield()) {
1498 // Don't initialize unnamed bitfields, e.g. "int : 20;"
1503 // Make sure we can use this declaration.
1506 InvalidUse = !SemaRef.CanUseDecl(*Field);
1508 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field,
1509 IList->getInit(Index)->getLocStart());
1517 InitializedEntity MemberEntity =
1518 InitializedEntity::InitializeMember(*Field, &Entity);
1519 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1520 StructuredList, StructuredIndex);
1521 InitializedSomething = true;
1523 if (DeclType->isUnionType() && !VerifyOnly) {
1524 // Initialize the first field within the union.
1525 StructuredList->setInitializedFieldInUnion(*Field);
1531 // Emit warnings for missing struct field initializers.
1532 if (!VerifyOnly && InitializedSomething && CheckForMissingFields &&
1533 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() &&
1534 !DeclType->isUnionType()) {
1535 // It is possible we have one or more unnamed bitfields remaining.
1536 // Find first (if any) named field and emit warning.
1537 for (RecordDecl::field_iterator it = Field, end = RD->field_end();
1539 if (!it->isUnnamedBitfield() && !it->hasInClassInitializer()) {
1540 SemaRef.Diag(IList->getSourceRange().getEnd(),
1541 diag::warn_missing_field_initializers) << it->getName();
1547 // Check that any remaining fields can be value-initialized.
1548 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() &&
1549 !Field->getType()->isIncompleteArrayType()) {
1550 // FIXME: Should check for holes left by designated initializers too.
1551 for (; Field != FieldEnd && !hadError; ++Field) {
1552 if (!Field->isUnnamedBitfield() && !Field->hasInClassInitializer())
1553 CheckValueInitializable(
1554 InitializedEntity::InitializeMember(*Field, &Entity));
1558 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1559 Index >= IList->getNumInits())
1562 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field,
1569 InitializedEntity MemberEntity =
1570 InitializedEntity::InitializeMember(*Field, &Entity);
1572 if (isa<InitListExpr>(IList->getInit(Index)))
1573 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1574 StructuredList, StructuredIndex);
1576 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index,
1577 StructuredList, StructuredIndex);
1580 /// \brief Expand a field designator that refers to a member of an
1581 /// anonymous struct or union into a series of field designators that
1582 /// refers to the field within the appropriate subobject.
1584 static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1585 DesignatedInitExpr *DIE,
1587 IndirectFieldDecl *IndirectField) {
1588 typedef DesignatedInitExpr::Designator Designator;
1590 // Build the replacement designators.
1591 SmallVector<Designator, 4> Replacements;
1592 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(),
1593 PE = IndirectField->chain_end(); PI != PE; ++PI) {
1595 Replacements.push_back(Designator((IdentifierInfo *)0,
1596 DIE->getDesignator(DesigIdx)->getDotLoc(),
1597 DIE->getDesignator(DesigIdx)->getFieldLoc()));
1599 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1601 assert(isa<FieldDecl>(*PI));
1602 Replacements.back().setField(cast<FieldDecl>(*PI));
1605 // Expand the current designator into the set of replacement
1606 // designators, so we have a full subobject path down to where the
1607 // member of the anonymous struct/union is actually stored.
1608 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0],
1609 &Replacements[0] + Replacements.size());
1612 /// \brief Given an implicit anonymous field, search the IndirectField that
1613 /// corresponds to FieldName.
1614 static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField,
1615 IdentifierInfo *FieldName) {
1619 assert(AnonField->isAnonymousStructOrUnion());
1620 Decl *NextDecl = AnonField->getNextDeclInContext();
1621 while (IndirectFieldDecl *IF =
1622 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) {
1623 if (FieldName == IF->getAnonField()->getIdentifier())
1625 NextDecl = NextDecl->getNextDeclInContext();
1630 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef,
1631 DesignatedInitExpr *DIE) {
1632 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1;
1633 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs);
1634 for (unsigned I = 0; I < NumIndexExprs; ++I)
1635 IndexExprs[I] = DIE->getSubExpr(I + 1);
1636 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(),
1637 DIE->size(), IndexExprs,
1638 DIE->getEqualOrColonLoc(),
1639 DIE->usesGNUSyntax(), DIE->getInit());
1644 // Callback to only accept typo corrections that are for field members of
1645 // the given struct or union.
1646 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback {
1648 explicit FieldInitializerValidatorCCC(RecordDecl *RD)
1651 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
1652 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>();
1653 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record);
1662 /// @brief Check the well-formedness of a C99 designated initializer.
1664 /// Determines whether the designated initializer @p DIE, which
1665 /// resides at the given @p Index within the initializer list @p
1666 /// IList, is well-formed for a current object of type @p DeclType
1667 /// (C99 6.7.8). The actual subobject that this designator refers to
1668 /// within the current subobject is returned in either
1669 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1671 /// @param IList The initializer list in which this designated
1672 /// initializer occurs.
1674 /// @param DIE The designated initializer expression.
1676 /// @param DesigIdx The index of the current designator.
1678 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17),
1679 /// into which the designation in @p DIE should refer.
1681 /// @param NextField If non-NULL and the first designator in @p DIE is
1682 /// a field, this will be set to the field declaration corresponding
1683 /// to the field named by the designator.
1685 /// @param NextElementIndex If non-NULL and the first designator in @p
1686 /// DIE is an array designator or GNU array-range designator, this
1687 /// will be set to the last index initialized by this designator.
1689 /// @param Index Index into @p IList where the designated initializer
1692 /// @param StructuredList The initializer list expression that
1693 /// describes all of the subobject initializers in the order they'll
1694 /// actually be initialized.
1696 /// @returns true if there was an error, false otherwise.
1698 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity,
1699 InitListExpr *IList,
1700 DesignatedInitExpr *DIE,
1702 QualType &CurrentObjectType,
1703 RecordDecl::field_iterator *NextField,
1704 llvm::APSInt *NextElementIndex,
1706 InitListExpr *StructuredList,
1707 unsigned &StructuredIndex,
1708 bool FinishSubobjectInit,
1709 bool TopLevelObject) {
1710 if (DesigIdx == DIE->size()) {
1711 // Check the actual initialization for the designated object type.
1712 bool prevHadError = hadError;
1714 // Temporarily remove the designator expression from the
1715 // initializer list that the child calls see, so that we don't try
1716 // to re-process the designator.
1717 unsigned OldIndex = Index;
1718 IList->setInit(OldIndex, DIE->getInit());
1720 CheckSubElementType(Entity, IList, CurrentObjectType, Index,
1721 StructuredList, StructuredIndex);
1723 // Restore the designated initializer expression in the syntactic
1724 // form of the initializer list.
1725 if (IList->getInit(OldIndex) != DIE->getInit())
1726 DIE->setInit(IList->getInit(OldIndex));
1727 IList->setInit(OldIndex, DIE);
1729 return hadError && !prevHadError;
1732 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx);
1733 bool IsFirstDesignator = (DesigIdx == 0);
1735 assert((IsFirstDesignator || StructuredList) &&
1736 "Need a non-designated initializer list to start from");
1738 // Determine the structural initializer list that corresponds to the
1739 // current subobject.
1740 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList)
1741 : getStructuredSubobjectInit(IList, Index, CurrentObjectType,
1742 StructuredList, StructuredIndex,
1743 SourceRange(D->getLocStart(),
1745 assert(StructuredList && "Expected a structured initializer list");
1748 if (D->isFieldDesignator()) {
1751 // If a designator has the form
1755 // then the current object (defined below) shall have
1756 // structure or union type and the identifier shall be the
1757 // name of a member of that type.
1758 const RecordType *RT = CurrentObjectType->getAs<RecordType>();
1760 SourceLocation Loc = D->getDotLoc();
1761 if (Loc.isInvalid())
1762 Loc = D->getFieldLoc();
1764 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr)
1765 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType;
1770 // Note: we perform a linear search of the fields here, despite
1771 // the fact that we have a faster lookup method, because we always
1772 // need to compute the field's index.
1773 FieldDecl *KnownField = D->getField();
1774 IdentifierInfo *FieldName = D->getFieldName();
1775 unsigned FieldIndex = 0;
1776 RecordDecl::field_iterator
1777 Field = RT->getDecl()->field_begin(),
1778 FieldEnd = RT->getDecl()->field_end();
1779 for (; Field != FieldEnd; ++Field) {
1780 if (Field->isUnnamedBitfield())
1783 // If we find a field representing an anonymous field, look in the
1784 // IndirectFieldDecl that follow for the designated initializer.
1785 if (!KnownField && Field->isAnonymousStructOrUnion()) {
1786 if (IndirectFieldDecl *IF =
1787 FindIndirectFieldDesignator(*Field, FieldName)) {
1788 // In verify mode, don't modify the original.
1790 DIE = CloneDesignatedInitExpr(SemaRef, DIE);
1791 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF);
1792 D = DIE->getDesignator(DesigIdx);
1796 if (KnownField && KnownField == *Field)
1798 if (FieldName && FieldName == Field->getIdentifier())
1804 if (Field == FieldEnd) {
1807 return true; // No typo correction when just trying this out.
1810 // There was no normal field in the struct with the designated
1811 // name. Perform another lookup for this name, which may find
1812 // something that we can't designate (e.g., a member function),
1813 // may find nothing, or may find a member of an anonymous
1815 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName);
1816 FieldDecl *ReplacementField = 0;
1817 if (Lookup.empty()) {
1818 // Name lookup didn't find anything. Determine whether this
1819 // was a typo for another field name.
1820 FieldInitializerValidatorCCC Validator(RT->getDecl());
1821 if (TypoCorrection Corrected = SemaRef.CorrectTypo(
1822 DeclarationNameInfo(FieldName, D->getFieldLoc()),
1823 Sema::LookupMemberName, /*Scope=*/ 0, /*SS=*/ 0, Validator,
1825 SemaRef.diagnoseTypo(
1827 SemaRef.PDiag(diag::err_field_designator_unknown_suggest)
1828 << FieldName << CurrentObjectType);
1829 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>();
1832 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown)
1833 << FieldName << CurrentObjectType;
1839 if (!ReplacementField) {
1840 // Name lookup found something, but it wasn't a field.
1841 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
1843 SemaRef.Diag(Lookup.front()->getLocation(),
1844 diag::note_field_designator_found);
1850 // The replacement field comes from typo correction; find it
1851 // in the list of fields.
1853 Field = RT->getDecl()->field_begin();
1854 for (; Field != FieldEnd; ++Field) {
1855 if (Field->isUnnamedBitfield())
1858 if (ReplacementField == *Field ||
1859 Field->getIdentifier() == ReplacementField->getIdentifier())
1867 // All of the fields of a union are located at the same place in
1868 // the initializer list.
1869 if (RT->getDecl()->isUnion()) {
1872 FieldDecl *CurrentField = StructuredList->getInitializedFieldInUnion();
1873 if (CurrentField && CurrentField != *Field) {
1874 assert(StructuredList->getNumInits() == 1
1875 && "A union should never have more than one initializer!");
1877 // we're about to throw away an initializer, emit warning
1878 SemaRef.Diag(D->getFieldLoc(),
1879 diag::warn_initializer_overrides)
1880 << D->getSourceRange();
1881 Expr *ExistingInit = StructuredList->getInit(0);
1882 SemaRef.Diag(ExistingInit->getLocStart(),
1883 diag::note_previous_initializer)
1884 << /*FIXME:has side effects=*/0
1885 << ExistingInit->getSourceRange();
1887 // remove existing initializer
1888 StructuredList->resizeInits(SemaRef.Context, 0);
1889 StructuredList->setInitializedFieldInUnion(0);
1892 StructuredList->setInitializedFieldInUnion(*Field);
1896 // Make sure we can use this declaration.
1899 InvalidUse = !SemaRef.CanUseDecl(*Field);
1901 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc());
1908 // Update the designator with the field declaration.
1909 D->setField(*Field);
1911 // Make sure that our non-designated initializer list has space
1912 // for a subobject corresponding to this field.
1913 if (FieldIndex >= StructuredList->getNumInits())
1914 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1);
1917 // This designator names a flexible array member.
1918 if (Field->getType()->isIncompleteArrayType()) {
1919 bool Invalid = false;
1920 if ((DesigIdx + 1) != DIE->size()) {
1921 // We can't designate an object within the flexible array
1922 // member (because GCC doesn't allow it).
1924 DesignatedInitExpr::Designator *NextD
1925 = DIE->getDesignator(DesigIdx + 1);
1926 SemaRef.Diag(NextD->getLocStart(),
1927 diag::err_designator_into_flexible_array_member)
1928 << SourceRange(NextD->getLocStart(),
1930 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1936 if (!hadError && !isa<InitListExpr>(DIE->getInit()) &&
1937 !isa<StringLiteral>(DIE->getInit())) {
1938 // The initializer is not an initializer list.
1940 SemaRef.Diag(DIE->getInit()->getLocStart(),
1941 diag::err_flexible_array_init_needs_braces)
1942 << DIE->getInit()->getSourceRange();
1943 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member)
1949 // Check GNU flexible array initializer.
1950 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field,
1959 // Initialize the array.
1960 bool prevHadError = hadError;
1961 unsigned newStructuredIndex = FieldIndex;
1962 unsigned OldIndex = Index;
1963 IList->setInit(Index, DIE->getInit());
1965 InitializedEntity MemberEntity =
1966 InitializedEntity::InitializeMember(*Field, &Entity);
1967 CheckSubElementType(MemberEntity, IList, Field->getType(), Index,
1968 StructuredList, newStructuredIndex);
1970 IList->setInit(OldIndex, DIE);
1971 if (hadError && !prevHadError) {
1976 StructuredIndex = FieldIndex;
1980 // Recurse to check later designated subobjects.
1981 QualType FieldType = Field->getType();
1982 unsigned newStructuredIndex = FieldIndex;
1984 InitializedEntity MemberEntity =
1985 InitializedEntity::InitializeMember(*Field, &Entity);
1986 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1,
1987 FieldType, 0, 0, Index,
1988 StructuredList, newStructuredIndex,
1993 // Find the position of the next field to be initialized in this
1998 // If this the first designator, our caller will continue checking
1999 // the rest of this struct/class/union subobject.
2000 if (IsFirstDesignator) {
2003 StructuredIndex = FieldIndex;
2007 if (!FinishSubobjectInit)
2010 // We've already initialized something in the union; we're done.
2011 if (RT->getDecl()->isUnion())
2014 // Check the remaining fields within this class/struct/union subobject.
2015 bool prevHadError = hadError;
2017 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index,
2018 StructuredList, FieldIndex);
2019 return hadError && !prevHadError;
2024 // If a designator has the form
2026 // [ constant-expression ]
2028 // then the current object (defined below) shall have array
2029 // type and the expression shall be an integer constant
2030 // expression. If the array is of unknown size, any
2031 // nonnegative value is valid.
2033 // Additionally, cope with the GNU extension that permits
2034 // designators of the form
2036 // [ constant-expression ... constant-expression ]
2037 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
2040 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
2041 << CurrentObjectType;
2046 Expr *IndexExpr = 0;
2047 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex;
2048 if (D->isArrayDesignator()) {
2049 IndexExpr = DIE->getArrayIndex(*D);
2050 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context);
2051 DesignatedEndIndex = DesignatedStartIndex;
2053 assert(D->isArrayRangeDesignator() && "Need array-range designator");
2055 DesignatedStartIndex =
2056 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context);
2057 DesignatedEndIndex =
2058 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context);
2059 IndexExpr = DIE->getArrayRangeEnd(*D);
2061 // Codegen can't handle evaluating array range designators that have side
2062 // effects, because we replicate the AST value for each initialized element.
2063 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple
2064 // elements with something that has a side effect, so codegen can emit an
2065 // "error unsupported" error instead of miscompiling the app.
2066 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&&
2067 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly)
2068 FullyStructuredList->sawArrayRangeDesignator();
2071 if (isa<ConstantArrayType>(AT)) {
2072 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false);
2073 DesignatedStartIndex
2074 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth());
2075 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned());
2077 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth());
2078 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned());
2079 if (DesignatedEndIndex >= MaxElements) {
2081 SemaRef.Diag(IndexExpr->getLocStart(),
2082 diag::err_array_designator_too_large)
2083 << DesignatedEndIndex.toString(10) << MaxElements.toString(10)
2084 << IndexExpr->getSourceRange();
2089 // Make sure the bit-widths and signedness match.
2090 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth())
2092 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth());
2093 else if (DesignatedStartIndex.getBitWidth() <
2094 DesignatedEndIndex.getBitWidth())
2095 DesignatedStartIndex
2096 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth());
2097 DesignatedStartIndex.setIsUnsigned(true);
2098 DesignatedEndIndex.setIsUnsigned(true);
2101 if (!VerifyOnly && StructuredList->isStringLiteralInit()) {
2102 // We're modifying a string literal init; we have to decompose the string
2103 // so we can modify the individual characters.
2104 ASTContext &Context = SemaRef.Context;
2105 Expr *SubExpr = StructuredList->getInit(0)->IgnoreParens();
2107 // Compute the character type
2108 QualType CharTy = AT->getElementType();
2110 // Compute the type of the integer literals.
2111 QualType PromotedCharTy = CharTy;
2112 if (CharTy->isPromotableIntegerType())
2113 PromotedCharTy = Context.getPromotedIntegerType(CharTy);
2114 unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
2116 if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
2117 // Get the length of the string.
2118 uint64_t StrLen = SL->getLength();
2119 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2120 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2121 StructuredList->resizeInits(Context, StrLen);
2123 // Build a literal for each character in the string, and put them into
2125 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2126 llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
2127 Expr *Init = new (Context) IntegerLiteral(
2128 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2129 if (CharTy != PromotedCharTy)
2130 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2131 Init, 0, VK_RValue);
2132 StructuredList->updateInit(Context, i, Init);
2135 ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
2137 Context.getObjCEncodingForType(E->getEncodedType(), Str);
2139 // Get the length of the string.
2140 uint64_t StrLen = Str.size();
2141 if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
2142 StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
2143 StructuredList->resizeInits(Context, StrLen);
2145 // Build a literal for each character in the string, and put them into
2147 for (unsigned i = 0, e = StrLen; i != e; ++i) {
2148 llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
2149 Expr *Init = new (Context) IntegerLiteral(
2150 Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
2151 if (CharTy != PromotedCharTy)
2152 Init = ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast,
2153 Init, 0, VK_RValue);
2154 StructuredList->updateInit(Context, i, Init);
2159 // Make sure that our non-designated initializer list has space
2160 // for a subobject corresponding to this array element.
2162 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
2163 StructuredList->resizeInits(SemaRef.Context,
2164 DesignatedEndIndex.getZExtValue() + 1);
2166 // Repeatedly perform subobject initializations in the range
2167 // [DesignatedStartIndex, DesignatedEndIndex].
2169 // Move to the next designator
2170 unsigned ElementIndex = DesignatedStartIndex.getZExtValue();
2171 unsigned OldIndex = Index;
2173 InitializedEntity ElementEntity =
2174 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity);
2176 while (DesignatedStartIndex <= DesignatedEndIndex) {
2177 // Recurse to check later designated subobjects.
2178 QualType ElementType = AT->getElementType();
2181 ElementEntity.setElementIndex(ElementIndex);
2182 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1,
2183 ElementType, 0, 0, Index,
2184 StructuredList, ElementIndex,
2185 (DesignatedStartIndex == DesignatedEndIndex),
2189 // Move to the next index in the array that we'll be initializing.
2190 ++DesignatedStartIndex;
2191 ElementIndex = DesignatedStartIndex.getZExtValue();
2194 // If this the first designator, our caller will continue checking
2195 // the rest of this array subobject.
2196 if (IsFirstDesignator) {
2197 if (NextElementIndex)
2198 *NextElementIndex = DesignatedStartIndex;
2199 StructuredIndex = ElementIndex;
2203 if (!FinishSubobjectInit)
2206 // Check the remaining elements within this array subobject.
2207 bool prevHadError = hadError;
2208 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex,
2209 /*SubobjectIsDesignatorContext=*/false, Index,
2210 StructuredList, ElementIndex);
2211 return hadError && !prevHadError;
2214 // Get the structured initializer list for a subobject of type
2215 // @p CurrentObjectType.
2217 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
2218 QualType CurrentObjectType,
2219 InitListExpr *StructuredList,
2220 unsigned StructuredIndex,
2221 SourceRange InitRange) {
2223 return 0; // No structured list in verification-only mode.
2224 Expr *ExistingInit = 0;
2225 if (!StructuredList)
2226 ExistingInit = SyntacticToSemantic.lookup(IList);
2227 else if (StructuredIndex < StructuredList->getNumInits())
2228 ExistingInit = StructuredList->getInit(StructuredIndex);
2230 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
2234 // We are creating an initializer list that initializes the
2235 // subobjects of the current object, but there was already an
2236 // initialization that completely initialized the current
2237 // subobject, e.g., by a compound literal:
2239 // struct X { int a, b; };
2240 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
2242 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
2243 // designated initializer re-initializes the whole
2244 // subobject [0], overwriting previous initializers.
2245 SemaRef.Diag(InitRange.getBegin(),
2246 diag::warn_subobject_initializer_overrides)
2248 SemaRef.Diag(ExistingInit->getLocStart(),
2249 diag::note_previous_initializer)
2250 << /*FIXME:has side effects=*/0
2251 << ExistingInit->getSourceRange();
2254 InitListExpr *Result
2255 = new (SemaRef.Context) InitListExpr(SemaRef.Context,
2256 InitRange.getBegin(), None,
2257 InitRange.getEnd());
2259 QualType ResultType = CurrentObjectType;
2260 if (!ResultType->isArrayType())
2261 ResultType = ResultType.getNonLValueExprType(SemaRef.Context);
2262 Result->setType(ResultType);
2264 // Pre-allocate storage for the structured initializer list.
2265 unsigned NumElements = 0;
2266 unsigned NumInits = 0;
2267 bool GotNumInits = false;
2268 if (!StructuredList) {
2269 NumInits = IList->getNumInits();
2271 } else if (Index < IList->getNumInits()) {
2272 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) {
2273 NumInits = SubList->getNumInits();
2278 if (const ArrayType *AType
2279 = SemaRef.Context.getAsArrayType(CurrentObjectType)) {
2280 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) {
2281 NumElements = CAType->getSize().getZExtValue();
2282 // Simple heuristic so that we don't allocate a very large
2283 // initializer with many empty entries at the end.
2284 if (GotNumInits && NumElements > NumInits)
2287 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>())
2288 NumElements = VType->getNumElements();
2289 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
2290 RecordDecl *RDecl = RType->getDecl();
2291 if (RDecl->isUnion())
2294 NumElements = std::distance(RDecl->field_begin(),
2295 RDecl->field_end());
2298 Result->reserveInits(SemaRef.Context, NumElements);
2300 // Link this new initializer list into the structured initializer
2303 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result);
2305 Result->setSyntacticForm(IList);
2306 SyntacticToSemantic[IList] = Result;
2312 /// Update the initializer at index @p StructuredIndex within the
2313 /// structured initializer list to the value @p expr.
2314 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
2315 unsigned &StructuredIndex,
2317 // No structured initializer list to update
2318 if (!StructuredList)
2321 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context,
2322 StructuredIndex, expr)) {
2323 // This initializer overwrites a previous initializer. Warn.
2324 SemaRef.Diag(expr->getLocStart(),
2325 diag::warn_initializer_overrides)
2326 << expr->getSourceRange();
2327 SemaRef.Diag(PrevInit->getLocStart(),
2328 diag::note_previous_initializer)
2329 << /*FIXME:has side effects=*/0
2330 << PrevInit->getSourceRange();
2336 /// Check that the given Index expression is a valid array designator
2337 /// value. This is essentially just a wrapper around
2338 /// VerifyIntegerConstantExpression that also checks for negative values
2339 /// and produces a reasonable diagnostic if there is a
2340 /// failure. Returns the index expression, possibly with an implicit cast
2341 /// added, on success. If everything went okay, Value will receive the
2342 /// value of the constant expression.
2344 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
2345 SourceLocation Loc = Index->getLocStart();
2347 // Make sure this is an integer constant expression.
2348 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value);
2349 if (Result.isInvalid())
2352 if (Value.isSigned() && Value.isNegative())
2353 return S.Diag(Loc, diag::err_array_designator_negative)
2354 << Value.toString(10) << Index->getSourceRange();
2356 Value.setIsUnsigned(true);
2360 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
2364 typedef DesignatedInitExpr::Designator ASTDesignator;
2366 bool Invalid = false;
2367 SmallVector<ASTDesignator, 32> Designators;
2368 SmallVector<Expr *, 32> InitExpressions;
2370 // Build designators and check array designator expressions.
2371 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) {
2372 const Designator &D = Desig.getDesignator(Idx);
2373 switch (D.getKind()) {
2374 case Designator::FieldDesignator:
2375 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(),
2379 case Designator::ArrayDesignator: {
2380 Expr *Index = static_cast<Expr *>(D.getArrayIndex());
2381 llvm::APSInt IndexValue;
2382 if (!Index->isTypeDependent() && !Index->isValueDependent())
2383 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take();
2387 Designators.push_back(ASTDesignator(InitExpressions.size(),
2389 D.getRBracketLoc()));
2390 InitExpressions.push_back(Index);
2395 case Designator::ArrayRangeDesignator: {
2396 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart());
2397 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd());
2398 llvm::APSInt StartValue;
2399 llvm::APSInt EndValue;
2400 bool StartDependent = StartIndex->isTypeDependent() ||
2401 StartIndex->isValueDependent();
2402 bool EndDependent = EndIndex->isTypeDependent() ||
2403 EndIndex->isValueDependent();
2404 if (!StartDependent)
2406 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take();
2408 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take();
2410 if (!StartIndex || !EndIndex)
2413 // Make sure we're comparing values with the same bit width.
2414 if (StartDependent || EndDependent) {
2415 // Nothing to compute.
2416 } else if (StartValue.getBitWidth() > EndValue.getBitWidth())
2417 EndValue = EndValue.extend(StartValue.getBitWidth());
2418 else if (StartValue.getBitWidth() < EndValue.getBitWidth())
2419 StartValue = StartValue.extend(EndValue.getBitWidth());
2421 if (!StartDependent && !EndDependent && EndValue < StartValue) {
2422 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range)
2423 << StartValue.toString(10) << EndValue.toString(10)
2424 << StartIndex->getSourceRange() << EndIndex->getSourceRange();
2427 Designators.push_back(ASTDesignator(InitExpressions.size(),
2430 D.getRBracketLoc()));
2431 InitExpressions.push_back(StartIndex);
2432 InitExpressions.push_back(EndIndex);
2440 if (Invalid || Init.isInvalid())
2443 // Clear out the expressions within the designation.
2444 Desig.ClearExprs(*this);
2446 DesignatedInitExpr *DIE
2447 = DesignatedInitExpr::Create(Context,
2448 Designators.data(), Designators.size(),
2449 InitExpressions, Loc, GNUSyntax,
2450 Init.takeAs<Expr>());
2452 if (!getLangOpts().C99)
2453 Diag(DIE->getLocStart(), diag::ext_designated_init)
2454 << DIE->getSourceRange();
2459 //===----------------------------------------------------------------------===//
2460 // Initialization entity
2461 //===----------------------------------------------------------------------===//
2463 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index,
2464 const InitializedEntity &Parent)
2465 : Parent(&Parent), Index(Index)
2467 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) {
2468 Kind = EK_ArrayElement;
2469 Type = AT->getElementType();
2470 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) {
2471 Kind = EK_VectorElement;
2472 Type = VT->getElementType();
2474 const ComplexType *CT = Parent.getType()->getAs<ComplexType>();
2475 assert(CT && "Unexpected type");
2476 Kind = EK_ComplexElement;
2477 Type = CT->getElementType();
2482 InitializedEntity::InitializeBase(ASTContext &Context,
2483 const CXXBaseSpecifier *Base,
2484 bool IsInheritedVirtualBase) {
2485 InitializedEntity Result;
2486 Result.Kind = EK_Base;
2488 Result.Base = reinterpret_cast<uintptr_t>(Base);
2489 if (IsInheritedVirtualBase)
2490 Result.Base |= 0x01;
2492 Result.Type = Base->getType();
2496 DeclarationName InitializedEntity::getName() const {
2497 switch (getKind()) {
2499 case EK_Parameter_CF_Audited: {
2500 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2501 return (D ? D->getDeclName() : DeclarationName());
2506 return VariableOrMember->getDeclName();
2508 case EK_LambdaCapture:
2509 return DeclarationName(Capture.VarID);
2517 case EK_ArrayElement:
2518 case EK_VectorElement:
2519 case EK_ComplexElement:
2520 case EK_BlockElement:
2521 case EK_CompoundLiteralInit:
2522 case EK_RelatedResult:
2523 return DeclarationName();
2526 llvm_unreachable("Invalid EntityKind!");
2529 DeclaratorDecl *InitializedEntity::getDecl() const {
2530 switch (getKind()) {
2533 return VariableOrMember;
2536 case EK_Parameter_CF_Audited:
2537 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1);
2545 case EK_ArrayElement:
2546 case EK_VectorElement:
2547 case EK_ComplexElement:
2548 case EK_BlockElement:
2549 case EK_LambdaCapture:
2550 case EK_CompoundLiteralInit:
2551 case EK_RelatedResult:
2555 llvm_unreachable("Invalid EntityKind!");
2558 bool InitializedEntity::allowsNRVO() const {
2559 switch (getKind()) {
2562 return LocAndNRVO.NRVO;
2566 case EK_Parameter_CF_Audited:
2570 case EK_CompoundLiteralInit:
2573 case EK_ArrayElement:
2574 case EK_VectorElement:
2575 case EK_ComplexElement:
2576 case EK_BlockElement:
2577 case EK_LambdaCapture:
2578 case EK_RelatedResult:
2585 unsigned InitializedEntity::dumpImpl(raw_ostream &OS) const {
2586 assert(getParent() != this);
2587 unsigned Depth = getParent() ? getParent()->dumpImpl(OS) : 0;
2588 for (unsigned I = 0; I != Depth; ++I)
2591 switch (getKind()) {
2592 case EK_Variable: OS << "Variable"; break;
2593 case EK_Parameter: OS << "Parameter"; break;
2594 case EK_Parameter_CF_Audited: OS << "CF audited function Parameter";
2596 case EK_Result: OS << "Result"; break;
2597 case EK_Exception: OS << "Exception"; break;
2598 case EK_Member: OS << "Member"; break;
2599 case EK_New: OS << "New"; break;
2600 case EK_Temporary: OS << "Temporary"; break;
2601 case EK_CompoundLiteralInit: OS << "CompoundLiteral";break;
2602 case EK_RelatedResult: OS << "RelatedResult"; break;
2603 case EK_Base: OS << "Base"; break;
2604 case EK_Delegating: OS << "Delegating"; break;
2605 case EK_ArrayElement: OS << "ArrayElement " << Index; break;
2606 case EK_VectorElement: OS << "VectorElement " << Index; break;
2607 case EK_ComplexElement: OS << "ComplexElement " << Index; break;
2608 case EK_BlockElement: OS << "Block"; break;
2609 case EK_LambdaCapture:
2610 OS << "LambdaCapture ";
2611 OS << DeclarationName(Capture.VarID);
2615 if (Decl *D = getDecl()) {
2617 cast<NamedDecl>(D)->printQualifiedName(OS);
2620 OS << " '" << getType().getAsString() << "'\n";
2625 void InitializedEntity::dump() const {
2626 dumpImpl(llvm::errs());
2629 //===----------------------------------------------------------------------===//
2630 // Initialization sequence
2631 //===----------------------------------------------------------------------===//
2633 void InitializationSequence::Step::Destroy() {
2635 case SK_ResolveAddressOfOverloadedFunction:
2636 case SK_CastDerivedToBaseRValue:
2637 case SK_CastDerivedToBaseXValue:
2638 case SK_CastDerivedToBaseLValue:
2639 case SK_BindReference:
2640 case SK_BindReferenceToTemporary:
2641 case SK_ExtraneousCopyToTemporary:
2642 case SK_UserConversion:
2643 case SK_QualificationConversionRValue:
2644 case SK_QualificationConversionXValue:
2645 case SK_QualificationConversionLValue:
2646 case SK_LValueToRValue:
2647 case SK_ListInitialization:
2648 case SK_ListConstructorCall:
2649 case SK_UnwrapInitList:
2650 case SK_RewrapInitList:
2651 case SK_ConstructorInitialization:
2652 case SK_ZeroInitialization:
2653 case SK_CAssignment:
2655 case SK_ObjCObjectConversion:
2657 case SK_ParenthesizedArrayInit:
2658 case SK_PassByIndirectCopyRestore:
2659 case SK_PassByIndirectRestore:
2660 case SK_ProduceObjCObject:
2661 case SK_StdInitializerList:
2662 case SK_OCLSamplerInit:
2663 case SK_OCLZeroEvent:
2666 case SK_ConversionSequence:
2667 case SK_ConversionSequenceNoNarrowing:
2672 bool InitializationSequence::isDirectReferenceBinding() const {
2673 return !Steps.empty() && Steps.back().Kind == SK_BindReference;
2676 bool InitializationSequence::isAmbiguous() const {
2680 switch (getFailureKind()) {
2681 case FK_TooManyInitsForReference:
2682 case FK_ArrayNeedsInitList:
2683 case FK_ArrayNeedsInitListOrStringLiteral:
2684 case FK_ArrayNeedsInitListOrWideStringLiteral:
2685 case FK_NarrowStringIntoWideCharArray:
2686 case FK_WideStringIntoCharArray:
2687 case FK_IncompatWideStringIntoWideChar:
2688 case FK_AddressOfOverloadFailed: // FIXME: Could do better
2689 case FK_NonConstLValueReferenceBindingToTemporary:
2690 case FK_NonConstLValueReferenceBindingToUnrelated:
2691 case FK_RValueReferenceBindingToLValue:
2692 case FK_ReferenceInitDropsQualifiers:
2693 case FK_ReferenceInitFailed:
2694 case FK_ConversionFailed:
2695 case FK_ConversionFromPropertyFailed:
2696 case FK_TooManyInitsForScalar:
2697 case FK_ReferenceBindingToInitList:
2698 case FK_InitListBadDestinationType:
2699 case FK_DefaultInitOfConst:
2701 case FK_ArrayTypeMismatch:
2702 case FK_NonConstantArrayInit:
2703 case FK_ListInitializationFailed:
2704 case FK_VariableLengthArrayHasInitializer:
2705 case FK_PlaceholderType:
2706 case FK_ExplicitConstructor:
2709 case FK_ReferenceInitOverloadFailed:
2710 case FK_UserConversionOverloadFailed:
2711 case FK_ConstructorOverloadFailed:
2712 case FK_ListConstructorOverloadFailed:
2713 return FailedOverloadResult == OR_Ambiguous;
2716 llvm_unreachable("Invalid EntityKind!");
2719 bool InitializationSequence::isConstructorInitialization() const {
2720 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization;
2724 InitializationSequence
2725 ::AddAddressOverloadResolutionStep(FunctionDecl *Function,
2726 DeclAccessPair Found,
2727 bool HadMultipleCandidates) {
2729 S.Kind = SK_ResolveAddressOfOverloadedFunction;
2730 S.Type = Function->getType();
2731 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2732 S.Function.Function = Function;
2733 S.Function.FoundDecl = Found;
2737 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType,
2741 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break;
2742 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break;
2743 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break;
2749 void InitializationSequence::AddReferenceBindingStep(QualType T,
2750 bool BindingTemporary) {
2752 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference;
2757 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) {
2759 S.Kind = SK_ExtraneousCopyToTemporary;
2765 InitializationSequence::AddUserConversionStep(FunctionDecl *Function,
2766 DeclAccessPair FoundDecl,
2768 bool HadMultipleCandidates) {
2770 S.Kind = SK_UserConversion;
2772 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2773 S.Function.Function = Function;
2774 S.Function.FoundDecl = FoundDecl;
2778 void InitializationSequence::AddQualificationConversionStep(QualType Ty,
2781 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning
2784 S.Kind = SK_QualificationConversionRValue;
2787 S.Kind = SK_QualificationConversionXValue;
2790 S.Kind = SK_QualificationConversionLValue;
2797 void InitializationSequence::AddLValueToRValueStep(QualType Ty) {
2798 assert(!Ty.hasQualifiers() && "rvalues may not have qualifiers");
2801 S.Kind = SK_LValueToRValue;
2806 void InitializationSequence::AddConversionSequenceStep(
2807 const ImplicitConversionSequence &ICS, QualType T,
2808 bool TopLevelOfInitList) {
2810 S.Kind = TopLevelOfInitList ? SK_ConversionSequenceNoNarrowing
2811 : SK_ConversionSequence;
2813 S.ICS = new ImplicitConversionSequence(ICS);
2817 void InitializationSequence::AddListInitializationStep(QualType T) {
2819 S.Kind = SK_ListInitialization;
2825 InitializationSequence
2826 ::AddConstructorInitializationStep(CXXConstructorDecl *Constructor,
2827 AccessSpecifier Access,
2829 bool HadMultipleCandidates,
2830 bool FromInitList, bool AsInitList) {
2832 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall
2833 : SK_ConstructorInitialization;
2835 S.Function.HadMultipleCandidates = HadMultipleCandidates;
2836 S.Function.Function = Constructor;
2837 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access);
2841 void InitializationSequence::AddZeroInitializationStep(QualType T) {
2843 S.Kind = SK_ZeroInitialization;
2848 void InitializationSequence::AddCAssignmentStep(QualType T) {
2850 S.Kind = SK_CAssignment;
2855 void InitializationSequence::AddStringInitStep(QualType T) {
2857 S.Kind = SK_StringInit;
2862 void InitializationSequence::AddObjCObjectConversionStep(QualType T) {
2864 S.Kind = SK_ObjCObjectConversion;
2869 void InitializationSequence::AddArrayInitStep(QualType T) {
2871 S.Kind = SK_ArrayInit;
2876 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) {
2878 S.Kind = SK_ParenthesizedArrayInit;
2883 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type,
2886 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore
2887 : SK_PassByIndirectRestore);
2892 void InitializationSequence::AddProduceObjCObjectStep(QualType T) {
2894 S.Kind = SK_ProduceObjCObject;
2899 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) {
2901 S.Kind = SK_StdInitializerList;
2906 void InitializationSequence::AddOCLSamplerInitStep(QualType T) {
2908 S.Kind = SK_OCLSamplerInit;
2913 void InitializationSequence::AddOCLZeroEventStep(QualType T) {
2915 S.Kind = SK_OCLZeroEvent;
2920 void InitializationSequence::RewrapReferenceInitList(QualType T,
2921 InitListExpr *Syntactic) {
2922 assert(Syntactic->getNumInits() == 1 &&
2923 "Can only rewrap trivial init lists.");
2925 S.Kind = SK_UnwrapInitList;
2926 S.Type = Syntactic->getInit(0)->getType();
2927 Steps.insert(Steps.begin(), S);
2929 S.Kind = SK_RewrapInitList;
2931 S.WrappingSyntacticList = Syntactic;
2935 void InitializationSequence::SetOverloadFailure(FailureKind Failure,
2936 OverloadingResult Result) {
2937 setSequenceKind(FailedSequence);
2938 this->Failure = Failure;
2939 this->FailedOverloadResult = Result;
2942 //===----------------------------------------------------------------------===//
2943 // Attempt initialization
2944 //===----------------------------------------------------------------------===//
2946 static void MaybeProduceObjCObject(Sema &S,
2947 InitializationSequence &Sequence,
2948 const InitializedEntity &Entity) {
2949 if (!S.getLangOpts().ObjCAutoRefCount) return;
2951 /// When initializing a parameter, produce the value if it's marked
2952 /// __attribute__((ns_consumed)).
2953 if (Entity.isParameterKind()) {
2954 if (!Entity.isParameterConsumed())
2957 assert(Entity.getType()->isObjCRetainableType() &&
2958 "consuming an object of unretainable type?");
2959 Sequence.AddProduceObjCObjectStep(Entity.getType());
2961 /// When initializing a return value, if the return type is a
2962 /// retainable type, then returns need to immediately retain the
2963 /// object. If an autorelease is required, it will be done at the
2965 } else if (Entity.getKind() == InitializedEntity::EK_Result) {
2966 if (!Entity.getType()->isObjCRetainableType())
2969 Sequence.AddProduceObjCObjectStep(Entity.getType());
2973 static void TryListInitialization(Sema &S,
2974 const InitializedEntity &Entity,
2975 const InitializationKind &Kind,
2976 InitListExpr *InitList,
2977 InitializationSequence &Sequence);
2979 /// \brief When initializing from init list via constructor, handle
2980 /// initialization of an object of type std::initializer_list<T>.
2982 /// \return true if we have handled initialization of an object of type
2983 /// std::initializer_list<T>, false otherwise.
2984 static bool TryInitializerListConstruction(Sema &S,
2987 InitializationSequence &Sequence) {
2989 if (!S.isStdInitializerList(DestType, &E))
2992 if (S.RequireCompleteType(List->getExprLoc(), E, 0)) {
2993 Sequence.setIncompleteTypeFailure(E);
2997 // Try initializing a temporary array from the init list.
2998 QualType ArrayType = S.Context.getConstantArrayType(
2999 E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
3000 List->getNumInits()),
3001 clang::ArrayType::Normal, 0);
3002 InitializedEntity HiddenArray =
3003 InitializedEntity::InitializeTemporary(ArrayType);
3004 InitializationKind Kind =
3005 InitializationKind::CreateDirectList(List->getExprLoc());
3006 TryListInitialization(S, HiddenArray, Kind, List, Sequence);
3008 Sequence.AddStdInitializerListConstructionStep(DestType);
3012 static OverloadingResult
3013 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc,
3015 OverloadCandidateSet &CandidateSet,
3016 ArrayRef<NamedDecl *> Ctors,
3017 OverloadCandidateSet::iterator &Best,
3018 bool CopyInitializing, bool AllowExplicit,
3019 bool OnlyListConstructors, bool InitListSyntax) {
3020 CandidateSet.clear();
3022 for (ArrayRef<NamedDecl *>::iterator
3023 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) {
3024 NamedDecl *D = *Con;
3025 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3026 bool SuppressUserConversions = false;
3028 // Find the constructor (which may be a template).
3029 CXXConstructorDecl *Constructor = 0;
3030 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3031 if (ConstructorTmpl)
3032 Constructor = cast<CXXConstructorDecl>(
3033 ConstructorTmpl->getTemplatedDecl());
3035 Constructor = cast<CXXConstructorDecl>(D);
3037 // C++11 [over.best.ics]p4:
3038 // However, when considering the argument of a constructor or
3039 // user-defined conversion function that is a candidate:
3040 // -- by 13.3.1.3 when invoked for the copying/moving of a temporary
3041 // in the second step of a class copy-initialization,
3042 // -- by 13.3.1.7 when passing the initializer list as a single
3043 // argument or when the initializer list has exactly one elementand
3044 // a conversion to some class X or reference to (possibly
3045 // cv-qualified) X is considered for the first parameter of a
3046 // constructor of X, or
3047 // -- by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases,
3048 // only standard conversion sequences and ellipsis conversion sequences
3050 if ((CopyInitializing || (InitListSyntax && Args.size() == 1)) &&
3051 Constructor->isCopyOrMoveConstructor())
3052 SuppressUserConversions = true;
3055 if (!Constructor->isInvalidDecl() &&
3056 (AllowExplicit || !Constructor->isExplicit()) &&
3057 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) {
3058 if (ConstructorTmpl)
3059 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3060 /*ExplicitArgs*/ 0, Args,
3061 CandidateSet, SuppressUserConversions);
3063 // C++ [over.match.copy]p1:
3064 // - When initializing a temporary to be bound to the first parameter
3065 // of a constructor that takes a reference to possibly cv-qualified
3066 // T as its first argument, called with a single argument in the
3067 // context of direct-initialization, explicit conversion functions
3068 // are also considered.
3069 bool AllowExplicitConv = AllowExplicit && !CopyInitializing &&
3071 Constructor->isCopyOrMoveConstructor();
3072 S.AddOverloadCandidate(Constructor, FoundDecl, Args, CandidateSet,
3073 SuppressUserConversions,
3074 /*PartialOverloading=*/false,
3075 /*AllowExplicit=*/AllowExplicitConv);
3080 // Perform overload resolution and return the result.
3081 return CandidateSet.BestViableFunction(S, DeclLoc, Best);
3084 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which
3085 /// enumerates the constructors of the initialized entity and performs overload
3086 /// resolution to select the best.
3087 /// If InitListSyntax is true, this is list-initialization of a non-aggregate
3089 static void TryConstructorInitialization(Sema &S,
3090 const InitializedEntity &Entity,
3091 const InitializationKind &Kind,
3092 MultiExprArg Args, QualType DestType,
3093 InitializationSequence &Sequence,
3094 bool InitListSyntax = false) {
3095 assert((!InitListSyntax || (Args.size() == 1 && isa<InitListExpr>(Args[0]))) &&
3096 "InitListSyntax must come with a single initializer list argument.");
3098 // The type we're constructing needs to be complete.
3099 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
3100 Sequence.setIncompleteTypeFailure(DestType);
3104 const RecordType *DestRecordType = DestType->getAs<RecordType>();
3105 assert(DestRecordType && "Constructor initialization requires record type");
3106 CXXRecordDecl *DestRecordDecl
3107 = cast<CXXRecordDecl>(DestRecordType->getDecl());
3109 // Build the candidate set directly in the initialization sequence
3110 // structure, so that it will persist if we fail.
3111 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3113 // Determine whether we are allowed to call explicit constructors or
3114 // explicit conversion operators.
3115 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax;
3116 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy;
3118 // - Otherwise, if T is a class type, constructors are considered. The
3119 // applicable constructors are enumerated, and the best one is chosen
3120 // through overload resolution.
3121 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
3122 // The container holding the constructors can under certain conditions
3123 // be changed while iterating (e.g. because of deserialization).
3124 // To be safe we copy the lookup results to a new container.
3125 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
3127 OverloadingResult Result = OR_No_Viable_Function;
3128 OverloadCandidateSet::iterator Best;
3129 bool AsInitializerList = false;
3131 // C++11 [over.match.list]p1:
3132 // When objects of non-aggregate type T are list-initialized, overload
3133 // resolution selects the constructor in two phases:
3134 // - Initially, the candidate functions are the initializer-list
3135 // constructors of the class T and the argument list consists of the
3136 // initializer list as a single argument.
3137 if (InitListSyntax) {
3138 InitListExpr *ILE = cast<InitListExpr>(Args[0]);
3139 AsInitializerList = true;
3141 // If the initializer list has no elements and T has a default constructor,
3142 // the first phase is omitted.
3143 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor())
3144 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3145 CandidateSet, Ctors, Best,
3146 CopyInitialization, AllowExplicit,
3147 /*OnlyListConstructor=*/true,
3150 // Time to unwrap the init list.
3151 Args = MultiExprArg(ILE->getInits(), ILE->getNumInits());
3154 // C++11 [over.match.list]p1:
3155 // - If no viable initializer-list constructor is found, overload resolution
3156 // is performed again, where the candidate functions are all the
3157 // constructors of the class T and the argument list consists of the
3158 // elements of the initializer list.
3159 if (Result == OR_No_Viable_Function) {
3160 AsInitializerList = false;
3161 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args,
3162 CandidateSet, Ctors, Best,
3163 CopyInitialization, AllowExplicit,
3164 /*OnlyListConstructors=*/false,
3168 Sequence.SetOverloadFailure(InitListSyntax ?
3169 InitializationSequence::FK_ListConstructorOverloadFailed :
3170 InitializationSequence::FK_ConstructorOverloadFailed,
3175 // C++11 [dcl.init]p6:
3176 // If a program calls for the default initialization of an object
3177 // of a const-qualified type T, T shall be a class type with a
3178 // user-provided default constructor.
3179 if (Kind.getKind() == InitializationKind::IK_Default &&
3180 Entity.getType().isConstQualified() &&
3181 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) {
3182 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
3186 // C++11 [over.match.list]p1:
3187 // In copy-list-initialization, if an explicit constructor is chosen, the
3188 // initializer is ill-formed.
3189 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
3190 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) {
3191 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor);
3195 // Add the constructor initialization step. Any cv-qualification conversion is
3196 // subsumed by the initialization.
3197 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3198 Sequence.AddConstructorInitializationStep(CtorDecl,
3199 Best->FoundDecl.getAccess(),
3200 DestType, HadMultipleCandidates,
3201 InitListSyntax, AsInitializerList);
3205 ResolveOverloadedFunctionForReferenceBinding(Sema &S,
3207 QualType &SourceType,
3208 QualType &UnqualifiedSourceType,
3209 QualType UnqualifiedTargetType,
3210 InitializationSequence &Sequence) {
3211 if (S.Context.getCanonicalType(UnqualifiedSourceType) ==
3212 S.Context.OverloadTy) {
3213 DeclAccessPair Found;
3214 bool HadMultipleCandidates = false;
3215 if (FunctionDecl *Fn
3216 = S.ResolveAddressOfOverloadedFunction(Initializer,
3217 UnqualifiedTargetType,
3219 &HadMultipleCandidates)) {
3220 Sequence.AddAddressOverloadResolutionStep(Fn, Found,
3221 HadMultipleCandidates);
3222 SourceType = Fn->getType();
3223 UnqualifiedSourceType = SourceType.getUnqualifiedType();
3224 } else if (!UnqualifiedTargetType->isRecordType()) {
3225 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3232 static void TryReferenceInitializationCore(Sema &S,
3233 const InitializedEntity &Entity,
3234 const InitializationKind &Kind,
3236 QualType cv1T1, QualType T1,
3238 QualType cv2T2, QualType T2,
3240 InitializationSequence &Sequence);
3242 static void TryValueInitialization(Sema &S,
3243 const InitializedEntity &Entity,
3244 const InitializationKind &Kind,
3245 InitializationSequence &Sequence,
3246 InitListExpr *InitList = 0);
3248 /// \brief Attempt list initialization of a reference.
3249 static void TryReferenceListInitialization(Sema &S,
3250 const InitializedEntity &Entity,
3251 const InitializationKind &Kind,
3252 InitListExpr *InitList,
3253 InitializationSequence &Sequence) {
3254 // First, catch C++03 where this isn't possible.
3255 if (!S.getLangOpts().CPlusPlus11) {
3256 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList);
3260 QualType DestType = Entity.getType();
3261 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3263 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3265 // Reference initialization via an initializer list works thus:
3266 // If the initializer list consists of a single element that is
3267 // reference-related to the referenced type, bind directly to that element
3268 // (possibly creating temporaries).
3269 // Otherwise, initialize a temporary with the initializer list and
3271 if (InitList->getNumInits() == 1) {
3272 Expr *Initializer = InitList->getInit(0);
3273 QualType cv2T2 = Initializer->getType();
3275 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3277 // If this fails, creating a temporary wouldn't work either.
3278 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3282 SourceLocation DeclLoc = Initializer->getLocStart();
3283 bool dummy1, dummy2, dummy3;
3284 Sema::ReferenceCompareResult RefRelationship
3285 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1,
3287 if (RefRelationship >= Sema::Ref_Related) {
3288 // Try to bind the reference here.
3289 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3290 T1Quals, cv2T2, T2, T2Quals, Sequence);
3292 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3296 // Update the initializer if we've resolved an overloaded function.
3297 if (Sequence.step_begin() != Sequence.step_end())
3298 Sequence.RewrapReferenceInitList(cv1T1, InitList);
3301 // Not reference-related. Create a temporary and bind to that.
3302 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3304 TryListInitialization(S, TempEntity, Kind, InitList, Sequence);
3306 if (DestType->isRValueReferenceType() ||
3307 (T1Quals.hasConst() && !T1Quals.hasVolatile()))
3308 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3311 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3315 /// \brief Attempt list initialization (C++0x [dcl.init.list])
3316 static void TryListInitialization(Sema &S,
3317 const InitializedEntity &Entity,
3318 const InitializationKind &Kind,
3319 InitListExpr *InitList,
3320 InitializationSequence &Sequence) {
3321 QualType DestType = Entity.getType();
3323 // C++ doesn't allow scalar initialization with more than one argument.
3324 // But C99 complex numbers are scalars and it makes sense there.
3325 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() &&
3326 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) {
3327 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar);
3330 if (DestType->isReferenceType()) {
3331 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence);
3334 if (DestType->isRecordType()) {
3335 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) {
3336 Sequence.setIncompleteTypeFailure(DestType);
3340 // C++11 [dcl.init.list]p3:
3341 // - If T is an aggregate, aggregate initialization is performed.
3342 if (!DestType->isAggregateType()) {
3343 if (S.getLangOpts().CPlusPlus11) {
3344 // - Otherwise, if the initializer list has no elements and T is a
3345 // class type with a default constructor, the object is
3346 // value-initialized.
3347 if (InitList->getNumInits() == 0) {
3348 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl();
3349 if (RD->hasDefaultConstructor()) {
3350 TryValueInitialization(S, Entity, Kind, Sequence, InitList);
3355 // - Otherwise, if T is a specialization of std::initializer_list<E>,
3356 // an initializer_list object constructed [...]
3357 if (TryInitializerListConstruction(S, InitList, DestType, Sequence))
3360 // - Otherwise, if T is a class type, constructors are considered.
3361 Expr *InitListAsExpr = InitList;
3362 TryConstructorInitialization(S, Entity, Kind, InitListAsExpr, DestType,
3363 Sequence, /*InitListSyntax*/true);
3366 InitializationSequence::FK_InitListBadDestinationType);
3370 if (S.getLangOpts().CPlusPlus && !DestType->isAggregateType() &&
3371 InitList->getNumInits() == 1 &&
3372 InitList->getInit(0)->getType()->isRecordType()) {
3373 // - Otherwise, if the initializer list has a single element of type E
3374 // [...references are handled above...], the object or reference is
3375 // initialized from that element; if a narrowing conversion is required
3376 // to convert the element to T, the program is ill-formed.
3378 // Per core-24034, this is direct-initialization if we were performing
3379 // direct-list-initialization and copy-initialization otherwise.
3380 // We can't use InitListChecker for this, because it always performs
3381 // copy-initialization. This only matters if we might use an 'explicit'
3382 // conversion operator, so we only need to handle the cases where the source
3383 // is of record type.
3384 InitializationKind SubKind =
3385 Kind.getKind() == InitializationKind::IK_DirectList
3386 ? InitializationKind::CreateDirect(Kind.getLocation(),
3387 InitList->getLBraceLoc(),
3388 InitList->getRBraceLoc())
3390 Expr *SubInit[1] = { InitList->getInit(0) };
3391 Sequence.InitializeFrom(S, Entity, SubKind, SubInit,
3392 /*TopLevelOfInitList*/true);
3394 Sequence.RewrapReferenceInitList(Entity.getType(), InitList);
3398 InitListChecker CheckInitList(S, Entity, InitList,
3399 DestType, /*VerifyOnly=*/true);
3400 if (CheckInitList.HadError()) {
3401 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed);
3405 // Add the list initialization step with the built init list.
3406 Sequence.AddListInitializationStep(DestType);
3409 /// \brief Try a reference initialization that involves calling a conversion
3411 static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
3412 const InitializedEntity &Entity,
3413 const InitializationKind &Kind,
3416 InitializationSequence &Sequence) {
3417 QualType DestType = Entity.getType();
3418 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3419 QualType T1 = cv1T1.getUnqualifiedType();
3420 QualType cv2T2 = Initializer->getType();
3421 QualType T2 = cv2T2.getUnqualifiedType();
3424 bool ObjCConversion;
3425 bool ObjCLifetimeConversion;
3426 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(),
3427 T1, T2, DerivedToBase,
3429 ObjCLifetimeConversion) &&
3430 "Must have incompatible references when binding via conversion");
3431 (void)DerivedToBase;
3432 (void)ObjCConversion;
3433 (void)ObjCLifetimeConversion;
3435 // Build the candidate set directly in the initialization sequence
3436 // structure, so that it will persist if we fail.
3437 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
3438 CandidateSet.clear();
3440 // Determine whether we are allowed to call explicit constructors or
3441 // explicit conversion operators.
3442 bool AllowExplicit = Kind.AllowExplicit();
3443 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctionsInRefBinding();
3445 const RecordType *T1RecordType = 0;
3446 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) &&
3447 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) {
3448 // The type we're converting to is a class type. Enumerate its constructors
3449 // to see if there is a suitable conversion.
3450 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl());
3452 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl);
3453 // The container holding the constructors can under certain conditions
3454 // be changed while iterating (e.g. because of deserialization).
3455 // To be safe we copy the lookup results to a new container.
3456 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
3457 for (SmallVectorImpl<NamedDecl *>::iterator
3458 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
3460 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
3462 // Find the constructor (which may be a template).
3463 CXXConstructorDecl *Constructor = 0;
3464 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
3465 if (ConstructorTmpl)
3466 Constructor = cast<CXXConstructorDecl>(
3467 ConstructorTmpl->getTemplatedDecl());
3469 Constructor = cast<CXXConstructorDecl>(D);
3471 if (!Constructor->isInvalidDecl() &&
3472 Constructor->isConvertingConstructor(AllowExplicit)) {
3473 if (ConstructorTmpl)
3474 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
3476 Initializer, CandidateSet,
3477 /*SuppressUserConversions=*/true);
3479 S.AddOverloadCandidate(Constructor, FoundDecl,
3480 Initializer, CandidateSet,
3481 /*SuppressUserConversions=*/true);
3485 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl())
3486 return OR_No_Viable_Function;
3488 const RecordType *T2RecordType = 0;
3489 if ((T2RecordType = T2->getAs<RecordType>()) &&
3490 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) {
3491 // The type we're converting from is a class type, enumerate its conversion
3493 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl());
3495 std::pair<CXXRecordDecl::conversion_iterator,
3496 CXXRecordDecl::conversion_iterator>
3497 Conversions = T2RecordDecl->getVisibleConversionFunctions();
3498 for (CXXRecordDecl::conversion_iterator
3499 I = Conversions.first, E = Conversions.second; I != E; ++I) {
3501 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
3502 if (isa<UsingShadowDecl>(D))
3503 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3505 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
3506 CXXConversionDecl *Conv;
3508 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3510 Conv = cast<CXXConversionDecl>(D);
3512 // If the conversion function doesn't return a reference type,
3513 // it can't be considered for this conversion unless we're allowed to
3514 // consider rvalues.
3515 // FIXME: Do we need to make sure that we only consider conversion
3516 // candidates with reference-compatible results? That might be needed to
3518 if ((AllowExplicitConvs || !Conv->isExplicit()) &&
3519 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){
3521 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
3522 ActingDC, Initializer,
3523 DestType, CandidateSet);
3525 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
3526 Initializer, DestType, CandidateSet);
3530 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl())
3531 return OR_No_Viable_Function;
3533 SourceLocation DeclLoc = Initializer->getLocStart();
3535 // Perform overload resolution. If it fails, return the failed result.
3536 OverloadCandidateSet::iterator Best;
3537 if (OverloadingResult Result
3538 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true))
3541 FunctionDecl *Function = Best->Function;
3542 // This is the overload that will be used for this initialization step if we
3543 // use this initialization. Mark it as referenced.
3544 Function->setReferenced();
3546 // Compute the returned type of the conversion.
3547 if (isa<CXXConversionDecl>(Function))
3548 T2 = Function->getResultType();
3552 // Add the user-defined conversion step.
3553 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3554 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
3555 T2.getNonLValueExprType(S.Context),
3556 HadMultipleCandidates);
3558 // Determine whether we need to perform derived-to-base or
3559 // cv-qualification adjustments.
3560 ExprValueKind VK = VK_RValue;
3561 if (T2->isLValueReferenceType())
3563 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>())
3564 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue;
3566 bool NewDerivedToBase = false;
3567 bool NewObjCConversion = false;
3568 bool NewObjCLifetimeConversion = false;
3569 Sema::ReferenceCompareResult NewRefRelationship
3570 = S.CompareReferenceRelationship(DeclLoc, T1,
3571 T2.getNonLValueExprType(S.Context),
3572 NewDerivedToBase, NewObjCConversion,
3573 NewObjCLifetimeConversion);
3574 if (NewRefRelationship == Sema::Ref_Incompatible) {
3575 // If the type we've converted to is not reference-related to the
3576 // type we're looking for, then there is another conversion step
3577 // we need to perform to produce a temporary of the right type
3578 // that we'll be binding to.
3579 ImplicitConversionSequence ICS;
3581 ICS.Standard = Best->FinalConversion;
3582 T2 = ICS.Standard.getToType(2);
3583 Sequence.AddConversionSequenceStep(ICS, T2);
3584 } else if (NewDerivedToBase)
3585 Sequence.AddDerivedToBaseCastStep(
3586 S.Context.getQualifiedType(T1,
3587 T2.getNonReferenceType().getQualifiers()),
3589 else if (NewObjCConversion)
3590 Sequence.AddObjCObjectConversionStep(
3591 S.Context.getQualifiedType(T1,
3592 T2.getNonReferenceType().getQualifiers()));
3594 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers())
3595 Sequence.AddQualificationConversionStep(cv1T1, VK);
3597 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType());
3601 static void CheckCXX98CompatAccessibleCopy(Sema &S,
3602 const InitializedEntity &Entity,
3605 /// \brief Attempt reference initialization (C++0x [dcl.init.ref])
3606 static void TryReferenceInitialization(Sema &S,
3607 const InitializedEntity &Entity,
3608 const InitializationKind &Kind,
3610 InitializationSequence &Sequence) {
3611 QualType DestType = Entity.getType();
3612 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType();
3614 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals);
3615 QualType cv2T2 = Initializer->getType();
3617 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals);
3619 // If the initializer is the address of an overloaded function, try
3620 // to resolve the overloaded function. If all goes well, T2 is the
3621 // type of the resulting function.
3622 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2,
3626 // Delegate everything else to a subfunction.
3627 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1,
3628 T1Quals, cv2T2, T2, T2Quals, Sequence);
3631 /// Converts the target of reference initialization so that it has the
3632 /// appropriate qualifiers and value kind.
3634 /// In this case, 'x' is an 'int' lvalue, but it needs to be 'const int'.
3637 /// const int &r = x;
3640 /// In this case the reference is binding to a bitfield lvalue, which isn't
3641 /// valid. Perform a load to create a lifetime-extended temporary instead.
3643 /// const int &r = someStruct.bitfield;
3645 static ExprValueKind
3646 convertQualifiersAndValueKindIfNecessary(Sema &S,
3647 InitializationSequence &Sequence,
3653 bool IsNonAddressableType = Initializer->refersToBitField() ||
3654 Initializer->refersToVectorElement();
3656 if (IsNonAddressableType) {
3657 // C++11 [dcl.init.ref]p5: [...] Otherwise, the reference shall be an
3658 // lvalue reference to a non-volatile const type, or the reference shall be
3659 // an rvalue reference.
3661 // If not, we can't make a temporary and bind to that. Give up and allow the
3662 // error to be diagnosed later.
3663 if (IsLValueRef && (!T1Quals.hasConst() || T1Quals.hasVolatile())) {
3664 assert(Initializer->isGLValue());
3665 return Initializer->getValueKind();
3668 // Force a load so we can materialize a temporary.
3669 Sequence.AddLValueToRValueStep(cv1T1.getUnqualifiedType());
3673 if (T1Quals != T2Quals) {
3674 Sequence.AddQualificationConversionStep(cv1T1,
3675 Initializer->getValueKind());
3678 return Initializer->getValueKind();
3682 /// \brief Reference initialization without resolving overloaded functions.
3683 static void TryReferenceInitializationCore(Sema &S,
3684 const InitializedEntity &Entity,
3685 const InitializationKind &Kind,
3687 QualType cv1T1, QualType T1,
3689 QualType cv2T2, QualType T2,
3691 InitializationSequence &Sequence) {
3692 QualType DestType = Entity.getType();
3693 SourceLocation DeclLoc = Initializer->getLocStart();
3694 // Compute some basic properties of the types and the initializer.
3695 bool isLValueRef = DestType->isLValueReferenceType();
3696 bool isRValueRef = !isLValueRef;
3697 bool DerivedToBase = false;
3698 bool ObjCConversion = false;
3699 bool ObjCLifetimeConversion = false;
3700 Expr::Classification InitCategory = Initializer->Classify(S.Context);
3701 Sema::ReferenceCompareResult RefRelationship
3702 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase,
3703 ObjCConversion, ObjCLifetimeConversion);
3705 // C++0x [dcl.init.ref]p5:
3706 // A reference to type "cv1 T1" is initialized by an expression of type
3707 // "cv2 T2" as follows:
3709 // - If the reference is an lvalue reference and the initializer
3711 // Note the analogous bullet points for rvalue refs to functions. Because
3712 // there are no function rvalues in C++, rvalue refs to functions are treated
3713 // like lvalue refs.
3714 OverloadingResult ConvOvlResult = OR_Success;
3715 bool T1Function = T1->isFunctionType();
3716 if (isLValueRef || T1Function) {
3717 if (InitCategory.isLValue() &&
3718 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
3719 (Kind.isCStyleOrFunctionalCast() &&
3720 RefRelationship == Sema::Ref_Related))) {
3721 // - is an lvalue (but is not a bit-field), and "cv1 T1" is
3722 // reference-compatible with "cv2 T2," or
3724 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a
3725 // bit-field when we're determining whether the reference initialization
3726 // can occur. However, we do pay attention to whether it is a bit-field
3727 // to decide whether we're actually binding to a temporary created from
3730 Sequence.AddDerivedToBaseCastStep(
3731 S.Context.getQualifiedType(T1, T2Quals),
3733 else if (ObjCConversion)
3734 Sequence.AddObjCObjectConversionStep(
3735 S.Context.getQualifiedType(T1, T2Quals));
3737 ExprValueKind ValueKind =
3738 convertQualifiersAndValueKindIfNecessary(S, Sequence, Initializer,
3739 cv1T1, T1Quals, T2Quals,
3741 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
3745 // - has a class type (i.e., T2 is a class type), where T1 is not
3746 // reference-related to T2, and can be implicitly converted to an
3747 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible
3748 // with "cv3 T3" (this conversion is selected by enumerating the
3749 // applicable conversion functions (13.3.1.6) and choosing the best
3750 // one through overload resolution (13.3)),
3751 // If we have an rvalue ref to function type here, the rhs must be
3752 // an rvalue. DR1287 removed the "implicitly" here.
3753 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() &&
3754 (isLValueRef || InitCategory.isRValue())) {
3755 ConvOvlResult = TryRefInitWithConversionFunction(
3756 S, Entity, Kind, Initializer, /*AllowRValues*/isRValueRef, Sequence);
3757 if (ConvOvlResult == OR_Success)
3759 if (ConvOvlResult != OR_No_Viable_Function)
3760 Sequence.SetOverloadFailure(
3761 InitializationSequence::FK_ReferenceInitOverloadFailed,
3766 // - Otherwise, the reference shall be an lvalue reference to a
3767 // non-volatile const type (i.e., cv1 shall be const), or the reference
3768 // shall be an rvalue reference.
3769 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) {
3770 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3771 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3772 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3773 Sequence.SetOverloadFailure(
3774 InitializationSequence::FK_ReferenceInitOverloadFailed,
3777 Sequence.SetFailed(InitCategory.isLValue()
3778 ? (RefRelationship == Sema::Ref_Related
3779 ? InitializationSequence::FK_ReferenceInitDropsQualifiers
3780 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated)
3781 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary);
3786 // - If the initializer expression
3787 // - is an xvalue, class prvalue, array prvalue, or function lvalue and
3788 // "cv1 T1" is reference-compatible with "cv2 T2"
3789 // Note: functions are handled below.
3791 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification ||
3792 (Kind.isCStyleOrFunctionalCast() &&
3793 RefRelationship == Sema::Ref_Related)) &&
3794 (InitCategory.isXValue() ||
3795 (InitCategory.isPRValue() && T2->isRecordType()) ||
3796 (InitCategory.isPRValue() && T2->isArrayType()))) {
3797 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue;
3798 if (InitCategory.isPRValue() && T2->isRecordType()) {
3799 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the
3800 // compiler the freedom to perform a copy here or bind to the
3801 // object, while C++0x requires that we bind directly to the
3802 // object. Hence, we always bind to the object without making an
3803 // extra copy. However, in C++03 requires that we check for the
3804 // presence of a suitable copy constructor:
3806 // The constructor that would be used to make the copy shall
3807 // be callable whether or not the copy is actually done.
3808 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt)
3809 Sequence.AddExtraneousCopyToTemporary(cv2T2);
3810 else if (S.getLangOpts().CPlusPlus11)
3811 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer);
3815 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals),
3817 else if (ObjCConversion)
3818 Sequence.AddObjCObjectConversionStep(
3819 S.Context.getQualifiedType(T1, T2Quals));
3821 ValueKind = convertQualifiersAndValueKindIfNecessary(S, Sequence,
3826 Sequence.AddReferenceBindingStep(cv1T1, ValueKind == VK_RValue);
3830 // - has a class type (i.e., T2 is a class type), where T1 is not
3831 // reference-related to T2, and can be implicitly converted to an
3832 // xvalue, class prvalue, or function lvalue of type "cv3 T3",
3833 // where "cv1 T1" is reference-compatible with "cv3 T3",
3835 // DR1287 removes the "implicitly" here.
3836 if (T2->isRecordType()) {
3837 if (RefRelationship == Sema::Ref_Incompatible) {
3838 ConvOvlResult = TryRefInitWithConversionFunction(
3839 S, Entity, Kind, Initializer, /*AllowRValues*/true, Sequence);
3841 Sequence.SetOverloadFailure(
3842 InitializationSequence::FK_ReferenceInitOverloadFailed,
3848 if ((RefRelationship == Sema::Ref_Compatible ||
3849 RefRelationship == Sema::Ref_Compatible_With_Added_Qualification) &&
3850 isRValueRef && InitCategory.isLValue()) {
3852 InitializationSequence::FK_RValueReferenceBindingToLValue);
3856 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3860 // - Otherwise, a temporary of type "cv1 T1" is created and initialized
3861 // from the initializer expression using the rules for a non-reference
3862 // copy-initialization (8.5). The reference is then bound to the
3865 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1);
3867 // FIXME: Why do we use an implicit conversion here rather than trying
3868 // copy-initialization?
3869 ImplicitConversionSequence ICS
3870 = S.TryImplicitConversion(Initializer, TempEntity.getType(),
3871 /*SuppressUserConversions=*/false,
3872 /*AllowExplicit=*/false,
3873 /*FIXME:InOverloadResolution=*/false,
3874 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
3875 /*AllowObjCWritebackConversion=*/false);
3878 // FIXME: Use the conversion function set stored in ICS to turn
3879 // this into an overloading ambiguity diagnostic. However, we need
3880 // to keep that set as an OverloadCandidateSet rather than as some
3881 // other kind of set.
3882 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty())
3883 Sequence.SetOverloadFailure(
3884 InitializationSequence::FK_ReferenceInitOverloadFailed,
3886 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy)
3887 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
3889 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed);
3892 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType());
3895 // [...] If T1 is reference-related to T2, cv1 must be the
3896 // same cv-qualification as, or greater cv-qualification
3897 // than, cv2; otherwise, the program is ill-formed.
3898 unsigned T1CVRQuals = T1Quals.getCVRQualifiers();
3899 unsigned T2CVRQuals = T2Quals.getCVRQualifiers();
3900 if (RefRelationship == Sema::Ref_Related &&
3901 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) {
3902 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers);
3906 // [...] If T1 is reference-related to T2 and the reference is an rvalue
3907 // reference, the initializer expression shall not be an lvalue.
3908 if (RefRelationship >= Sema::Ref_Related && !isLValueRef &&
3909 InitCategory.isLValue()) {
3911 InitializationSequence::FK_RValueReferenceBindingToLValue);
3915 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true);
3919 /// \brief Attempt character array initialization from a string literal
3920 /// (C++ [dcl.init.string], C99 6.7.8).
3921 static void TryStringLiteralInitialization(Sema &S,
3922 const InitializedEntity &Entity,
3923 const InitializationKind &Kind,
3925 InitializationSequence &Sequence) {
3926 Sequence.AddStringInitStep(Entity.getType());
3929 /// \brief Attempt value initialization (C++ [dcl.init]p7).
3930 static void TryValueInitialization(Sema &S,
3931 const InitializedEntity &Entity,
3932 const InitializationKind &Kind,
3933 InitializationSequence &Sequence,
3934 InitListExpr *InitList) {
3935 assert((!InitList || InitList->getNumInits() == 0) &&
3936 "Shouldn't use value-init for non-empty init lists");
3938 // C++98 [dcl.init]p5, C++11 [dcl.init]p7:
3940 // To value-initialize an object of type T means:
3941 QualType T = Entity.getType();
3943 // -- if T is an array type, then each element is value-initialized;
3944 T = S.Context.getBaseElementType(T);
3946 if (const RecordType *RT = T->getAs<RecordType>()) {
3947 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
3948 bool NeedZeroInitialization = true;
3949 if (!S.getLangOpts().CPlusPlus11) {
3951 // -- if T is a class type (clause 9) with a user-declared constructor
3952 // (12.1), then the default constructor for T is called (and the
3953 // initialization is ill-formed if T has no accessible default
3955 if (ClassDecl->hasUserDeclaredConstructor())
3956 NeedZeroInitialization = false;
3959 // -- if T is a class type (clause 9) with either no default constructor
3960 // (12.1 [class.ctor]) or a default constructor that is user-provided
3961 // or deleted, then the object is default-initialized;
3962 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl);
3963 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted())
3964 NeedZeroInitialization = false;
3967 // -- if T is a (possibly cv-qualified) non-union class type without a
3968 // user-provided or deleted default constructor, then the object is
3969 // zero-initialized and, if T has a non-trivial default constructor,
3970 // default-initialized;
3971 // The 'non-union' here was removed by DR1502. The 'non-trivial default
3972 // constructor' part was removed by DR1507.
3973 if (NeedZeroInitialization)
3974 Sequence.AddZeroInitializationStep(Entity.getType());
3977 // -- if T is a non-union class type without a user-declared constructor,
3978 // then every non-static data member and base class component of T is
3979 // value-initialized;
3980 // [...] A program that calls for [...] value-initialization of an
3981 // entity of reference type is ill-formed.
3983 // C++11 doesn't need this handling, because value-initialization does not
3984 // occur recursively there, and the implicit default constructor is
3985 // defined as deleted in the problematic cases.
3986 if (!S.getLangOpts().CPlusPlus11 &&
3987 ClassDecl->hasUninitializedReferenceMember()) {
3988 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference);
3992 // If this is list-value-initialization, pass the empty init list on when
3993 // building the constructor call. This affects the semantics of a few
3994 // things (such as whether an explicit default constructor can be called).
3995 Expr *InitListAsExpr = InitList;
3996 MultiExprArg Args(&InitListAsExpr, InitList ? 1 : 0);
3997 bool InitListSyntax = InitList;
3999 return TryConstructorInitialization(S, Entity, Kind, Args, T, Sequence,
4004 Sequence.AddZeroInitializationStep(Entity.getType());
4007 /// \brief Attempt default initialization (C++ [dcl.init]p6).
4008 static void TryDefaultInitialization(Sema &S,
4009 const InitializedEntity &Entity,
4010 const InitializationKind &Kind,
4011 InitializationSequence &Sequence) {
4012 assert(Kind.getKind() == InitializationKind::IK_Default);
4014 // C++ [dcl.init]p6:
4015 // To default-initialize an object of type T means:
4016 // - if T is an array type, each element is default-initialized;
4017 QualType DestType = S.Context.getBaseElementType(Entity.getType());
4019 // - if T is a (possibly cv-qualified) class type (Clause 9), the default
4020 // constructor for T is called (and the initialization is ill-formed if
4021 // T has no accessible default constructor);
4022 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) {
4023 TryConstructorInitialization(S, Entity, Kind, None, DestType, Sequence);
4027 // - otherwise, no initialization is performed.
4029 // If a program calls for the default initialization of an object of
4030 // a const-qualified type T, T shall be a class type with a user-provided
4031 // default constructor.
4032 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) {
4033 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst);
4037 // If the destination type has a lifetime property, zero-initialize it.
4038 if (DestType.getQualifiers().hasObjCLifetime()) {
4039 Sequence.AddZeroInitializationStep(Entity.getType());
4044 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]),
4045 /// which enumerates all conversion functions and performs overload resolution
4046 /// to select the best.
4047 static void TryUserDefinedConversion(Sema &S,
4048 const InitializedEntity &Entity,
4049 const InitializationKind &Kind,
4051 InitializationSequence &Sequence,
4052 bool TopLevelOfInitList) {
4053 QualType DestType = Entity.getType();
4054 assert(!DestType->isReferenceType() && "References are handled elsewhere");
4055 QualType SourceType = Initializer->getType();
4056 assert((DestType->isRecordType() || SourceType->isRecordType()) &&
4057 "Must have a class type to perform a user-defined conversion");
4059 // Build the candidate set directly in the initialization sequence
4060 // structure, so that it will persist if we fail.
4061 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet();
4062 CandidateSet.clear();
4064 // Determine whether we are allowed to call explicit constructors or
4065 // explicit conversion operators.
4066 bool AllowExplicit = Kind.AllowExplicit();
4068 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) {
4069 // The type we're converting to is a class type. Enumerate its constructors
4070 // to see if there is a suitable conversion.
4071 CXXRecordDecl *DestRecordDecl
4072 = cast<CXXRecordDecl>(DestRecordType->getDecl());
4074 // Try to complete the type we're converting to.
4075 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) {
4076 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl);
4077 // The container holding the constructors can under certain conditions
4078 // be changed while iterating. To be safe we copy the lookup results
4079 // to a new container.
4080 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end());
4081 for (SmallVectorImpl<NamedDecl *>::iterator
4082 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end();
4083 Con != ConEnd; ++Con) {
4084 NamedDecl *D = *Con;
4085 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess());
4087 // Find the constructor (which may be a template).
4088 CXXConstructorDecl *Constructor = 0;
4089 FunctionTemplateDecl *ConstructorTmpl
4090 = dyn_cast<FunctionTemplateDecl>(D);
4091 if (ConstructorTmpl)
4092 Constructor = cast<CXXConstructorDecl>(
4093 ConstructorTmpl->getTemplatedDecl());
4095 Constructor = cast<CXXConstructorDecl>(D);
4097 if (!Constructor->isInvalidDecl() &&
4098 Constructor->isConvertingConstructor(AllowExplicit)) {
4099 if (ConstructorTmpl)
4100 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl,
4102 Initializer, CandidateSet,
4103 /*SuppressUserConversions=*/true);
4105 S.AddOverloadCandidate(Constructor, FoundDecl,
4106 Initializer, CandidateSet,
4107 /*SuppressUserConversions=*/true);
4113 SourceLocation DeclLoc = Initializer->getLocStart();
4115 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) {
4116 // The type we're converting from is a class type, enumerate its conversion
4119 // We can only enumerate the conversion functions for a complete type; if
4120 // the type isn't complete, simply skip this step.
4121 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) {
4122 CXXRecordDecl *SourceRecordDecl
4123 = cast<CXXRecordDecl>(SourceRecordType->getDecl());
4125 std::pair<CXXRecordDecl::conversion_iterator,
4126 CXXRecordDecl::conversion_iterator>
4127 Conversions = SourceRecordDecl->getVisibleConversionFunctions();
4128 for (CXXRecordDecl::conversion_iterator
4129 I = Conversions.first, E = Conversions.second; I != E; ++I) {
4131 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4132 if (isa<UsingShadowDecl>(D))
4133 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4135 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
4136 CXXConversionDecl *Conv;
4138 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4140 Conv = cast<CXXConversionDecl>(D);
4142 if (AllowExplicit || !Conv->isExplicit()) {
4144 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(),
4145 ActingDC, Initializer, DestType,
4148 S.AddConversionCandidate(Conv, I.getPair(), ActingDC,
4149 Initializer, DestType, CandidateSet);
4155 // Perform overload resolution. If it fails, return the failed result.
4156 OverloadCandidateSet::iterator Best;
4157 if (OverloadingResult Result
4158 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) {
4159 Sequence.SetOverloadFailure(
4160 InitializationSequence::FK_UserConversionOverloadFailed,
4165 FunctionDecl *Function = Best->Function;
4166 Function->setReferenced();
4167 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4169 if (isa<CXXConstructorDecl>(Function)) {
4170 // Add the user-defined conversion step. Any cv-qualification conversion is
4171 // subsumed by the initialization. Per DR5, the created temporary is of the
4172 // cv-unqualified type of the destination.
4173 Sequence.AddUserConversionStep(Function, Best->FoundDecl,
4174 DestType.getUnqualifiedType(),
4175 HadMultipleCandidates);
4179 // Add the user-defined conversion step that calls the conversion function.
4180 QualType ConvType = Function->getCallResultType();
4181 if (ConvType->getAs<RecordType>()) {
4182 // If we're converting to a class type, there may be an copy of
4183 // the resulting temporary object (possible to create an object of
4184 // a base class type). That copy is not a separate conversion, so
4185 // we just make a note of the actual destination type (possibly a
4186 // base class of the type returned by the conversion function) and
4187 // let the user-defined conversion step handle the conversion.
4188 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType,
4189 HadMultipleCandidates);
4193 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType,
4194 HadMultipleCandidates);
4196 // If the conversion following the call to the conversion function
4197 // is interesting, add it as a separate step.
4198 if (Best->FinalConversion.First || Best->FinalConversion.Second ||
4199 Best->FinalConversion.Third) {
4200 ImplicitConversionSequence ICS;
4202 ICS.Standard = Best->FinalConversion;
4203 Sequence.AddConversionSequenceStep(ICS, DestType, TopLevelOfInitList);
4207 /// An egregious hack for compatibility with libstdc++-4.2: in <tr1/hashtable>,
4208 /// a function with a pointer return type contains a 'return false;' statement.
4209 /// In C++11, 'false' is not a null pointer, so this breaks the build of any
4210 /// code using that header.
4212 /// Work around this by treating 'return false;' as zero-initializing the result
4213 /// if it's used in a pointer-returning function in a system header.
4214 static bool isLibstdcxxPointerReturnFalseHack(Sema &S,
4215 const InitializedEntity &Entity,
4217 return S.getLangOpts().CPlusPlus11 &&
4218 Entity.getKind() == InitializedEntity::EK_Result &&
4219 Entity.getType()->isPointerType() &&
4220 isa<CXXBoolLiteralExpr>(Init) &&
4221 !cast<CXXBoolLiteralExpr>(Init)->getValue() &&
4222 S.getSourceManager().isInSystemHeader(Init->getExprLoc());
4225 /// The non-zero enum values here are indexes into diagnostic alternatives.
4226 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar };
4228 /// Determines whether this expression is an acceptable ICR source.
4229 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e,
4230 bool isAddressOf, bool &isWeakAccess) {
4232 e = e->IgnoreParens();
4234 // Skip address-of nodes.
4235 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) {
4236 if (op->getOpcode() == UO_AddrOf)
4237 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true,
4240 // Skip certain casts.
4241 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) {
4242 switch (ce->getCastKind()) {
4245 case CK_LValueBitCast:
4247 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess);
4249 case CK_ArrayToPointerDecay:
4250 return IIK_nonscalar;
4252 case CK_NullToPointer:
4259 // If we have a declaration reference, it had better be a local variable.
4260 } else if (isa<DeclRefExpr>(e)) {
4261 // set isWeakAccess to true, to mean that there will be an implicit
4262 // load which requires a cleanup.
4263 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
4264 isWeakAccess = true;
4266 if (!isAddressOf) return IIK_nonlocal;
4268 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl());
4269 if (!var) return IIK_nonlocal;
4271 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal);
4273 // If we have a conditional operator, check both sides.
4274 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) {
4275 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf,
4279 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess);
4281 // These are never scalar.
4282 } else if (isa<ArraySubscriptExpr>(e)) {
4283 return IIK_nonscalar;
4285 // Otherwise, it needs to be a null pointer constant.
4287 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull)
4288 ? IIK_okay : IIK_nonlocal);
4291 return IIK_nonlocal;
4294 /// Check whether the given expression is a valid operand for an
4295 /// indirect copy/restore.
4296 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {
4297 assert(src->isRValue());
4298 bool isWeakAccess = false;
4299 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess);
4300 // If isWeakAccess to true, there will be an implicit
4301 // load which requires a cleanup.
4302 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess)
4303 S.ExprNeedsCleanups = true;
4305 if (iik == IIK_okay) return;
4307 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback)
4308 << ((unsigned) iik - 1) // shift index into diagnostic explanations
4309 << src->getSourceRange();
4312 /// \brief Determine whether we have compatible array types for the
4313 /// purposes of GNU by-copy array initialization.
4314 static bool hasCompatibleArrayTypes(ASTContext &Context,
4315 const ArrayType *Dest,
4316 const ArrayType *Source) {
4317 // If the source and destination array types are equivalent, we're
4319 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0)))
4322 // Make sure that the element types are the same.
4323 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType()))
4326 // The only mismatch we allow is when the destination is an
4327 // incomplete array type and the source is a constant array type.
4328 return Source->isConstantArrayType() && Dest->isIncompleteArrayType();
4331 static bool tryObjCWritebackConversion(Sema &S,
4332 InitializationSequence &Sequence,
4333 const InitializedEntity &Entity,
4334 Expr *Initializer) {
4335 bool ArrayDecay = false;
4336 QualType ArgType = Initializer->getType();
4337 QualType ArgPointee;
4338 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) {
4340 ArgPointee = ArgArrayType->getElementType();
4341 ArgType = S.Context.getPointerType(ArgPointee);
4344 // Handle write-back conversion.
4345 QualType ConvertedArgType;
4346 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(),
4350 // We should copy unless we're passing to an argument explicitly
4352 bool ShouldCopy = true;
4353 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4354 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4356 // Do we need an lvalue conversion?
4357 if (ArrayDecay || Initializer->isGLValue()) {
4358 ImplicitConversionSequence ICS;
4360 ICS.Standard.setAsIdentityConversion();
4362 QualType ResultType;
4364 ICS.Standard.First = ICK_Array_To_Pointer;
4365 ResultType = S.Context.getPointerType(ArgPointee);
4367 ICS.Standard.First = ICK_Lvalue_To_Rvalue;
4368 ResultType = Initializer->getType().getNonLValueExprType(S.Context);
4371 Sequence.AddConversionSequenceStep(ICS, ResultType);
4374 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4378 static bool TryOCLSamplerInitialization(Sema &S,
4379 InitializationSequence &Sequence,
4381 Expr *Initializer) {
4382 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() ||
4383 !Initializer->isIntegerConstantExpr(S.getASTContext()))
4386 Sequence.AddOCLSamplerInitStep(DestType);
4391 // OpenCL 1.2 spec, s6.12.10
4393 // The event argument can also be used to associate the
4394 // async_work_group_copy with a previous async copy allowing
4395 // an event to be shared by multiple async copies; otherwise
4396 // event should be zero.
4398 static bool TryOCLZeroEventInitialization(Sema &S,
4399 InitializationSequence &Sequence,
4401 Expr *Initializer) {
4402 if (!S.getLangOpts().OpenCL || !DestType->isEventT() ||
4403 !Initializer->isIntegerConstantExpr(S.getASTContext()) ||
4404 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0))
4407 Sequence.AddOCLZeroEventStep(DestType);
4411 InitializationSequence::InitializationSequence(Sema &S,
4412 const InitializedEntity &Entity,
4413 const InitializationKind &Kind,
4415 bool TopLevelOfInitList)
4416 : FailedCandidateSet(Kind.getLocation()) {
4417 InitializeFrom(S, Entity, Kind, Args, TopLevelOfInitList);
4420 void InitializationSequence::InitializeFrom(Sema &S,
4421 const InitializedEntity &Entity,
4422 const InitializationKind &Kind,
4424 bool TopLevelOfInitList) {
4425 ASTContext &Context = S.Context;
4427 // Eliminate non-overload placeholder types in the arguments. We
4428 // need to do this before checking whether types are dependent
4429 // because lowering a pseudo-object expression might well give us
4430 // something of dependent type.
4431 for (unsigned I = 0, E = Args.size(); I != E; ++I)
4432 if (Args[I]->getType()->isNonOverloadPlaceholderType()) {
4433 // FIXME: should we be doing this here?
4434 ExprResult result = S.CheckPlaceholderExpr(Args[I]);
4435 if (result.isInvalid()) {
4436 SetFailed(FK_PlaceholderType);
4439 Args[I] = result.take();
4442 // C++0x [dcl.init]p16:
4443 // The semantics of initializers are as follows. The destination type is
4444 // the type of the object or reference being initialized and the source
4445 // type is the type of the initializer expression. The source type is not
4446 // defined when the initializer is a braced-init-list or when it is a
4447 // parenthesized list of expressions.
4448 QualType DestType = Entity.getType();
4450 if (DestType->isDependentType() ||
4451 Expr::hasAnyTypeDependentArguments(Args)) {
4452 SequenceKind = DependentSequence;
4456 // Almost everything is a normal sequence.
4457 setSequenceKind(NormalSequence);
4459 QualType SourceType;
4460 Expr *Initializer = 0;
4461 if (Args.size() == 1) {
4462 Initializer = Args[0];
4463 if (!isa<InitListExpr>(Initializer))
4464 SourceType = Initializer->getType();
4467 // - If the initializer is a (non-parenthesized) braced-init-list, the
4468 // object is list-initialized (8.5.4).
4469 if (Kind.getKind() != InitializationKind::IK_Direct) {
4470 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) {
4471 TryListInitialization(S, Entity, Kind, InitList, *this);
4476 // - If the destination type is a reference type, see 8.5.3.
4477 if (DestType->isReferenceType()) {
4478 // C++0x [dcl.init.ref]p1:
4479 // A variable declared to be a T& or T&&, that is, "reference to type T"
4480 // (8.3.2), shall be initialized by an object, or function, of type T or
4481 // by an object that can be converted into a T.
4482 // (Therefore, multiple arguments are not permitted.)
4483 if (Args.size() != 1)
4484 SetFailed(FK_TooManyInitsForReference);
4486 TryReferenceInitialization(S, Entity, Kind, Args[0], *this);
4490 // - If the initializer is (), the object is value-initialized.
4491 if (Kind.getKind() == InitializationKind::IK_Value ||
4492 (Kind.getKind() == InitializationKind::IK_Direct && Args.empty())) {
4493 TryValueInitialization(S, Entity, Kind, *this);
4497 // Handle default initialization.
4498 if (Kind.getKind() == InitializationKind::IK_Default) {
4499 TryDefaultInitialization(S, Entity, Kind, *this);
4503 // - If the destination type is an array of characters, an array of
4504 // char16_t, an array of char32_t, or an array of wchar_t, and the
4505 // initializer is a string literal, see 8.5.2.
4506 // - Otherwise, if the destination type is an array, the program is
4508 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) {
4509 if (Initializer && isa<VariableArrayType>(DestAT)) {
4510 SetFailed(FK_VariableLengthArrayHasInitializer);
4515 switch (IsStringInit(Initializer, DestAT, Context)) {
4517 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this);
4519 case SIF_NarrowStringIntoWideChar:
4520 SetFailed(FK_NarrowStringIntoWideCharArray);
4522 case SIF_WideStringIntoChar:
4523 SetFailed(FK_WideStringIntoCharArray);
4525 case SIF_IncompatWideStringIntoWideChar:
4526 SetFailed(FK_IncompatWideStringIntoWideChar);
4533 // Note: as an GNU C extension, we allow initialization of an
4534 // array from a compound literal that creates an array of the same
4535 // type, so long as the initializer has no side effects.
4536 if (!S.getLangOpts().CPlusPlus && Initializer &&
4537 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) &&
4538 Initializer->getType()->isArrayType()) {
4539 const ArrayType *SourceAT
4540 = Context.getAsArrayType(Initializer->getType());
4541 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT))
4542 SetFailed(FK_ArrayTypeMismatch);
4543 else if (Initializer->HasSideEffects(S.Context))
4544 SetFailed(FK_NonConstantArrayInit);
4546 AddArrayInitStep(DestType);
4549 // Note: as a GNU C++ extension, we allow list-initialization of a
4550 // class member of array type from a parenthesized initializer list.
4551 else if (S.getLangOpts().CPlusPlus &&
4552 Entity.getKind() == InitializedEntity::EK_Member &&
4553 Initializer && isa<InitListExpr>(Initializer)) {
4554 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer),
4556 AddParenthesizedArrayInitStep(DestType);
4557 } else if (DestAT->getElementType()->isCharType())
4558 SetFailed(FK_ArrayNeedsInitListOrStringLiteral);
4559 else if (IsWideCharCompatible(DestAT->getElementType(), Context))
4560 SetFailed(FK_ArrayNeedsInitListOrWideStringLiteral);
4562 SetFailed(FK_ArrayNeedsInitList);
4567 // Determine whether we should consider writeback conversions for
4569 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount &&
4570 Entity.isParameterKind();
4572 // We're at the end of the line for C: it's either a write-back conversion
4573 // or it's a C assignment. There's no need to check anything else.
4574 if (!S.getLangOpts().CPlusPlus) {
4575 // If allowed, check whether this is an Objective-C writeback conversion.
4576 if (allowObjCWritebackConversion &&
4577 tryObjCWritebackConversion(S, *this, Entity, Initializer)) {
4581 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer))
4584 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer))
4587 // Handle initialization in C
4588 AddCAssignmentStep(DestType);
4589 MaybeProduceObjCObject(S, *this, Entity);
4593 assert(S.getLangOpts().CPlusPlus);
4595 // - If the destination type is a (possibly cv-qualified) class type:
4596 if (DestType->isRecordType()) {
4597 // - If the initialization is direct-initialization, or if it is
4598 // copy-initialization where the cv-unqualified version of the
4599 // source type is the same class as, or a derived class of, the
4600 // class of the destination, constructors are considered. [...]
4601 if (Kind.getKind() == InitializationKind::IK_Direct ||
4602 (Kind.getKind() == InitializationKind::IK_Copy &&
4603 (Context.hasSameUnqualifiedType(SourceType, DestType) ||
4604 S.IsDerivedFrom(SourceType, DestType))))
4605 TryConstructorInitialization(S, Entity, Kind, Args,
4606 Entity.getType(), *this);
4607 // - Otherwise (i.e., for the remaining copy-initialization cases),
4608 // user-defined conversion sequences that can convert from the source
4609 // type to the destination type or (when a conversion function is
4610 // used) to a derived class thereof are enumerated as described in
4611 // 13.3.1.4, and the best one is chosen through overload resolution
4614 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4615 TopLevelOfInitList);
4619 if (Args.size() > 1) {
4620 SetFailed(FK_TooManyInitsForScalar);
4623 assert(Args.size() == 1 && "Zero-argument case handled above");
4625 // - Otherwise, if the source type is a (possibly cv-qualified) class
4626 // type, conversion functions are considered.
4627 if (!SourceType.isNull() && SourceType->isRecordType()) {
4628 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this,
4629 TopLevelOfInitList);
4630 MaybeProduceObjCObject(S, *this, Entity);
4634 // - Otherwise, the initial value of the object being initialized is the
4635 // (possibly converted) value of the initializer expression. Standard
4636 // conversions (Clause 4) will be used, if necessary, to convert the
4637 // initializer expression to the cv-unqualified version of the
4638 // destination type; no user-defined conversions are considered.
4640 ImplicitConversionSequence ICS
4641 = S.TryImplicitConversion(Initializer, Entity.getType(),
4642 /*SuppressUserConversions*/true,
4643 /*AllowExplicitConversions*/ false,
4644 /*InOverloadResolution*/ false,
4645 /*CStyle=*/Kind.isCStyleOrFunctionalCast(),
4646 allowObjCWritebackConversion);
4648 if (ICS.isStandard() &&
4649 ICS.Standard.Second == ICK_Writeback_Conversion) {
4650 // Objective-C ARC writeback conversion.
4652 // We should copy unless we're passing to an argument explicitly
4654 bool ShouldCopy = true;
4655 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl()))
4656 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out);
4658 // If there was an lvalue adjustment, add it as a separate conversion.
4659 if (ICS.Standard.First == ICK_Array_To_Pointer ||
4660 ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
4661 ImplicitConversionSequence LvalueICS;
4662 LvalueICS.setStandard();
4663 LvalueICS.Standard.setAsIdentityConversion();
4664 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0));
4665 LvalueICS.Standard.First = ICS.Standard.First;
4666 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0));
4669 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy);
4670 } else if (ICS.isBad()) {
4672 if (isLibstdcxxPointerReturnFalseHack(S, Entity, Initializer)) {
4673 AddZeroInitializationStep(Entity.getType());
4674 } else if (Initializer->getType() == Context.OverloadTy &&
4675 !S.ResolveAddressOfOverloadedFunction(Initializer, DestType,
4677 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed);
4679 SetFailed(InitializationSequence::FK_ConversionFailed);
4681 AddConversionSequenceStep(ICS, Entity.getType(), TopLevelOfInitList);
4683 MaybeProduceObjCObject(S, *this, Entity);
4687 InitializationSequence::~InitializationSequence() {
4688 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(),
4689 StepEnd = Steps.end();
4690 Step != StepEnd; ++Step)
4694 //===----------------------------------------------------------------------===//
4695 // Perform initialization
4696 //===----------------------------------------------------------------------===//
4697 static Sema::AssignmentAction
4698 getAssignmentAction(const InitializedEntity &Entity, bool Diagnose = false) {
4699 switch(Entity.getKind()) {
4700 case InitializedEntity::EK_Variable:
4701 case InitializedEntity::EK_New:
4702 case InitializedEntity::EK_Exception:
4703 case InitializedEntity::EK_Base:
4704 case InitializedEntity::EK_Delegating:
4705 return Sema::AA_Initializing;
4707 case InitializedEntity::EK_Parameter:
4708 if (Entity.getDecl() &&
4709 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4710 return Sema::AA_Sending;
4712 return Sema::AA_Passing;
4714 case InitializedEntity::EK_Parameter_CF_Audited:
4715 if (Entity.getDecl() &&
4716 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext()))
4717 return Sema::AA_Sending;
4719 return !Diagnose ? Sema::AA_Passing : Sema::AA_Passing_CFAudited;
4721 case InitializedEntity::EK_Result:
4722 return Sema::AA_Returning;
4724 case InitializedEntity::EK_Temporary:
4725 case InitializedEntity::EK_RelatedResult:
4726 // FIXME: Can we tell apart casting vs. converting?
4727 return Sema::AA_Casting;
4729 case InitializedEntity::EK_Member:
4730 case InitializedEntity::EK_ArrayElement:
4731 case InitializedEntity::EK_VectorElement:
4732 case InitializedEntity::EK_ComplexElement:
4733 case InitializedEntity::EK_BlockElement:
4734 case InitializedEntity::EK_LambdaCapture:
4735 case InitializedEntity::EK_CompoundLiteralInit:
4736 return Sema::AA_Initializing;
4739 llvm_unreachable("Invalid EntityKind!");
4742 /// \brief Whether we should bind a created object as a temporary when
4743 /// initializing the given entity.
4744 static bool shouldBindAsTemporary(const InitializedEntity &Entity) {
4745 switch (Entity.getKind()) {
4746 case InitializedEntity::EK_ArrayElement:
4747 case InitializedEntity::EK_Member:
4748 case InitializedEntity::EK_Result:
4749 case InitializedEntity::EK_New:
4750 case InitializedEntity::EK_Variable:
4751 case InitializedEntity::EK_Base:
4752 case InitializedEntity::EK_Delegating:
4753 case InitializedEntity::EK_VectorElement:
4754 case InitializedEntity::EK_ComplexElement:
4755 case InitializedEntity::EK_Exception:
4756 case InitializedEntity::EK_BlockElement:
4757 case InitializedEntity::EK_LambdaCapture:
4758 case InitializedEntity::EK_CompoundLiteralInit:
4761 case InitializedEntity::EK_Parameter:
4762 case InitializedEntity::EK_Parameter_CF_Audited:
4763 case InitializedEntity::EK_Temporary:
4764 case InitializedEntity::EK_RelatedResult:
4768 llvm_unreachable("missed an InitializedEntity kind?");
4771 /// \brief Whether the given entity, when initialized with an object
4772 /// created for that initialization, requires destruction.
4773 static bool shouldDestroyTemporary(const InitializedEntity &Entity) {
4774 switch (Entity.getKind()) {
4775 case InitializedEntity::EK_Result:
4776 case InitializedEntity::EK_New:
4777 case InitializedEntity::EK_Base:
4778 case InitializedEntity::EK_Delegating:
4779 case InitializedEntity::EK_VectorElement:
4780 case InitializedEntity::EK_ComplexElement:
4781 case InitializedEntity::EK_BlockElement:
4782 case InitializedEntity::EK_LambdaCapture:
4785 case InitializedEntity::EK_Member:
4786 case InitializedEntity::EK_Variable:
4787 case InitializedEntity::EK_Parameter:
4788 case InitializedEntity::EK_Parameter_CF_Audited:
4789 case InitializedEntity::EK_Temporary:
4790 case InitializedEntity::EK_ArrayElement:
4791 case InitializedEntity::EK_Exception:
4792 case InitializedEntity::EK_CompoundLiteralInit:
4793 case InitializedEntity::EK_RelatedResult:
4797 llvm_unreachable("missed an InitializedEntity kind?");
4800 /// \brief Look for copy and move constructors and constructor templates, for
4801 /// copying an object via direct-initialization (per C++11 [dcl.init]p16).
4802 static void LookupCopyAndMoveConstructors(Sema &S,
4803 OverloadCandidateSet &CandidateSet,
4804 CXXRecordDecl *Class,
4805 Expr *CurInitExpr) {
4806 DeclContext::lookup_result R = S.LookupConstructors(Class);
4807 // The container holding the constructors can under certain conditions
4808 // be changed while iterating (e.g. because of deserialization).
4809 // To be safe we copy the lookup results to a new container.
4810 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end());
4811 for (SmallVectorImpl<NamedDecl *>::iterator
4812 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) {
4814 CXXConstructorDecl *Constructor = 0;
4816 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) {
4817 // Handle copy/moveconstructors, only.
4818 if (!Constructor || Constructor->isInvalidDecl() ||
4819 !Constructor->isCopyOrMoveConstructor() ||
4820 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4823 DeclAccessPair FoundDecl
4824 = DeclAccessPair::make(Constructor, Constructor->getAccess());
4825 S.AddOverloadCandidate(Constructor, FoundDecl,
4826 CurInitExpr, CandidateSet);
4830 // Handle constructor templates.
4831 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D);
4832 if (ConstructorTmpl->isInvalidDecl())
4835 Constructor = cast<CXXConstructorDecl>(
4836 ConstructorTmpl->getTemplatedDecl());
4837 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true))
4840 // FIXME: Do we need to limit this to copy-constructor-like
4842 DeclAccessPair FoundDecl
4843 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess());
4844 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0,
4845 CurInitExpr, CandidateSet, true);
4849 /// \brief Get the location at which initialization diagnostics should appear.
4850 static SourceLocation getInitializationLoc(const InitializedEntity &Entity,
4851 Expr *Initializer) {
4852 switch (Entity.getKind()) {
4853 case InitializedEntity::EK_Result:
4854 return Entity.getReturnLoc();
4856 case InitializedEntity::EK_Exception:
4857 return Entity.getThrowLoc();
4859 case InitializedEntity::EK_Variable:
4860 return Entity.getDecl()->getLocation();
4862 case InitializedEntity::EK_LambdaCapture:
4863 return Entity.getCaptureLoc();
4865 case InitializedEntity::EK_ArrayElement:
4866 case InitializedEntity::EK_Member:
4867 case InitializedEntity::EK_Parameter:
4868 case InitializedEntity::EK_Parameter_CF_Audited:
4869 case InitializedEntity::EK_Temporary:
4870 case InitializedEntity::EK_New:
4871 case InitializedEntity::EK_Base:
4872 case InitializedEntity::EK_Delegating:
4873 case InitializedEntity::EK_VectorElement:
4874 case InitializedEntity::EK_ComplexElement:
4875 case InitializedEntity::EK_BlockElement:
4876 case InitializedEntity::EK_CompoundLiteralInit:
4877 case InitializedEntity::EK_RelatedResult:
4878 return Initializer->getLocStart();
4880 llvm_unreachable("missed an InitializedEntity kind?");
4883 /// \brief Make a (potentially elidable) temporary copy of the object
4884 /// provided by the given initializer by calling the appropriate copy
4887 /// \param S The Sema object used for type-checking.
4889 /// \param T The type of the temporary object, which must either be
4890 /// the type of the initializer expression or a superclass thereof.
4892 /// \param Entity The entity being initialized.
4894 /// \param CurInit The initializer expression.
4896 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that
4897 /// is permitted in C++03 (but not C++0x) when binding a reference to
4900 /// \returns An expression that copies the initializer expression into
4901 /// a temporary object, or an error expression if a copy could not be
4903 static ExprResult CopyObject(Sema &S,
4905 const InitializedEntity &Entity,
4907 bool IsExtraneousCopy) {
4908 // Determine which class type we're copying to.
4909 Expr *CurInitExpr = (Expr *)CurInit.get();
4910 CXXRecordDecl *Class = 0;
4911 if (const RecordType *Record = T->getAs<RecordType>())
4912 Class = cast<CXXRecordDecl>(Record->getDecl());
4916 // C++0x [class.copy]p32:
4917 // When certain criteria are met, an implementation is allowed to
4918 // omit the copy/move construction of a class object, even if the
4919 // copy/move constructor and/or destructor for the object have
4920 // side effects. [...]
4921 // - when a temporary class object that has not been bound to a
4922 // reference (12.2) would be copied/moved to a class object
4923 // with the same cv-unqualified type, the copy/move operation
4924 // can be omitted by constructing the temporary object
4925 // directly into the target of the omitted copy/move
4927 // Note that the other three bullets are handled elsewhere. Copy
4928 // elision for return statements and throw expressions are handled as part
4929 // of constructor initialization, while copy elision for exception handlers
4930 // is handled by the run-time.
4931 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class);
4932 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get());
4934 // Make sure that the type we are copying is complete.
4935 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete))
4938 // Perform overload resolution using the class's copy/move constructors.
4939 // Only consider constructors and constructor templates. Per
4940 // C++0x [dcl.init]p16, second bullet to class types, this initialization
4941 // is direct-initialization.
4942 OverloadCandidateSet CandidateSet(Loc);
4943 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr);
4945 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4947 OverloadCandidateSet::iterator Best;
4948 switch (CandidateSet.BestViableFunction(S, Loc, Best)) {
4952 case OR_No_Viable_Function:
4953 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext()
4954 ? diag::ext_rvalue_to_reference_temp_copy_no_viable
4955 : diag::err_temp_copy_no_viable)
4956 << (int)Entity.getKind() << CurInitExpr->getType()
4957 << CurInitExpr->getSourceRange();
4958 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
4959 if (!IsExtraneousCopy || S.isSFINAEContext())
4964 S.Diag(Loc, diag::err_temp_copy_ambiguous)
4965 << (int)Entity.getKind() << CurInitExpr->getType()
4966 << CurInitExpr->getSourceRange();
4967 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
4971 S.Diag(Loc, diag::err_temp_copy_deleted)
4972 << (int)Entity.getKind() << CurInitExpr->getType()
4973 << CurInitExpr->getSourceRange();
4974 S.NoteDeletedFunction(Best->Function);
4978 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
4979 SmallVector<Expr*, 8> ConstructorArgs;
4980 CurInit.release(); // Ownership transferred into MultiExprArg, below.
4982 S.CheckConstructorAccess(Loc, Constructor, Entity,
4983 Best->FoundDecl.getAccess(), IsExtraneousCopy);
4985 if (IsExtraneousCopy) {
4986 // If this is a totally extraneous copy for C++03 reference
4987 // binding purposes, just return the original initialization
4988 // expression. We don't generate an (elided) copy operation here
4989 // because doing so would require us to pass down a flag to avoid
4990 // infinite recursion, where each step adds another extraneous,
4993 // Instantiate the default arguments of any extra parameters in
4994 // the selected copy constructor, as if we were going to create a
4995 // proper call to the copy constructor.
4996 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) {
4997 ParmVarDecl *Parm = Constructor->getParamDecl(I);
4998 if (S.RequireCompleteType(Loc, Parm->getType(),
4999 diag::err_call_incomplete_argument))
5002 // Build the default argument expression; we don't actually care
5003 // if this succeeds or not, because this routine will complain
5004 // if there was a problem.
5005 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm);
5008 return S.Owned(CurInitExpr);
5011 // Determine the arguments required to actually perform the
5012 // constructor call (we might have derived-to-base conversions, or
5013 // the copy constructor may have default arguments).
5014 if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
5017 // Actually perform the constructor call.
5018 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable,
5020 HadMultipleCandidates,
5023 CXXConstructExpr::CK_Complete,
5026 // If we're supposed to bind temporaries, do so.
5027 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity))
5028 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
5032 /// \brief Check whether elidable copy construction for binding a reference to
5033 /// a temporary would have succeeded if we were building in C++98 mode, for
5035 static void CheckCXX98CompatAccessibleCopy(Sema &S,
5036 const InitializedEntity &Entity,
5037 Expr *CurInitExpr) {
5038 assert(S.getLangOpts().CPlusPlus11);
5040 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>();
5044 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr);
5045 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc)
5046 == DiagnosticsEngine::Ignored)
5049 // Find constructors which would have been considered.
5050 OverloadCandidateSet CandidateSet(Loc);
5051 LookupCopyAndMoveConstructors(
5052 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr);
5054 // Perform overload resolution.
5055 OverloadCandidateSet::iterator Best;
5056 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best);
5058 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy)
5059 << OR << (int)Entity.getKind() << CurInitExpr->getType()
5060 << CurInitExpr->getSourceRange();
5064 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
5065 Entity, Best->FoundDecl.getAccess(), Diag);
5066 // FIXME: Check default arguments as far as that's possible.
5069 case OR_No_Viable_Function:
5071 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr);
5076 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr);
5081 S.NoteDeletedFunction(Best->Function);
5086 void InitializationSequence::PrintInitLocationNote(Sema &S,
5087 const InitializedEntity &Entity) {
5088 if (Entity.isParameterKind() && Entity.getDecl()) {
5089 if (Entity.getDecl()->getLocation().isInvalid())
5092 if (Entity.getDecl()->getDeclName())
5093 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here)
5094 << Entity.getDecl()->getDeclName();
5096 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here);
5098 else if (Entity.getKind() == InitializedEntity::EK_RelatedResult &&
5099 Entity.getMethodDecl())
5100 S.Diag(Entity.getMethodDecl()->getLocation(),
5101 diag::note_method_return_type_change)
5102 << Entity.getMethodDecl()->getDeclName();
5105 static bool isReferenceBinding(const InitializationSequence::Step &s) {
5106 return s.Kind == InitializationSequence::SK_BindReference ||
5107 s.Kind == InitializationSequence::SK_BindReferenceToTemporary;
5110 /// Returns true if the parameters describe a constructor initialization of
5111 /// an explicit temporary object, e.g. "Point(x, y)".
5112 static bool isExplicitTemporary(const InitializedEntity &Entity,
5113 const InitializationKind &Kind,
5115 switch (Entity.getKind()) {
5116 case InitializedEntity::EK_Temporary:
5117 case InitializedEntity::EK_CompoundLiteralInit:
5118 case InitializedEntity::EK_RelatedResult:
5124 switch (Kind.getKind()) {
5125 case InitializationKind::IK_DirectList:
5127 // FIXME: Hack to work around cast weirdness.
5128 case InitializationKind::IK_Direct:
5129 case InitializationKind::IK_Value:
5130 return NumArgs != 1;
5137 PerformConstructorInitialization(Sema &S,
5138 const InitializedEntity &Entity,
5139 const InitializationKind &Kind,
5141 const InitializationSequence::Step& Step,
5142 bool &ConstructorInitRequiresZeroInit,
5143 bool IsListInitialization,
5144 SourceLocation LBraceLoc,
5145 SourceLocation RBraceLoc) {
5146 unsigned NumArgs = Args.size();
5147 CXXConstructorDecl *Constructor
5148 = cast<CXXConstructorDecl>(Step.Function.Function);
5149 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates;
5151 // Build a call to the selected constructor.
5152 SmallVector<Expr*, 8> ConstructorArgs;
5153 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid())
5154 ? Kind.getEqualLoc()
5155 : Kind.getLocation();
5157 if (Kind.getKind() == InitializationKind::IK_Default) {
5158 // Force even a trivial, implicit default constructor to be
5159 // semantically checked. We do this explicitly because we don't build
5160 // the definition for completely trivial constructors.
5161 assert(Constructor->getParent() && "No parent class for constructor.");
5162 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() &&
5163 Constructor->isTrivial() && !Constructor->isUsed(false))
5164 S.DefineImplicitDefaultConstructor(Loc, Constructor);
5167 ExprResult CurInit = S.Owned((Expr *)0);
5169 // C++ [over.match.copy]p1:
5170 // - When initializing a temporary to be bound to the first parameter
5171 // of a constructor that takes a reference to possibly cv-qualified
5172 // T as its first argument, called with a single argument in the
5173 // context of direct-initialization, explicit conversion functions
5174 // are also considered.
5175 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() &&
5177 Constructor->isCopyOrMoveConstructor();
5179 // Determine the arguments required to actually perform the constructor
5181 if (S.CompleteConstructorCall(Constructor, Args,
5182 Loc, ConstructorArgs,
5184 IsListInitialization))
5188 if (isExplicitTemporary(Entity, Kind, NumArgs)) {
5189 // An explicitly-constructed temporary, e.g., X(1, 2).
5190 S.MarkFunctionReferenced(Loc, Constructor);
5191 if (S.DiagnoseUseOfDecl(Constructor, Loc))
5194 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
5196 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
5197 SourceRange ParenOrBraceRange =
5198 (Kind.getKind() == InitializationKind::IK_DirectList)
5199 ? SourceRange(LBraceLoc, RBraceLoc)
5200 : Kind.getParenRange();
5203 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor,
5204 TSInfo, ConstructorArgs,
5206 HadMultipleCandidates,
5207 IsListInitialization,
5208 ConstructorInitRequiresZeroInit));
5210 CXXConstructExpr::ConstructionKind ConstructKind =
5211 CXXConstructExpr::CK_Complete;
5213 if (Entity.getKind() == InitializedEntity::EK_Base) {
5214 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ?
5215 CXXConstructExpr::CK_VirtualBase :
5216 CXXConstructExpr::CK_NonVirtualBase;
5217 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) {
5218 ConstructKind = CXXConstructExpr::CK_Delegating;
5221 // Only get the parenthesis range if it is a direct construction.
5222 SourceRange parenRange =
5223 Kind.getKind() == InitializationKind::IK_Direct ?
5224 Kind.getParenRange() : SourceRange();
5226 // If the entity allows NRVO, mark the construction as elidable
5228 if (Entity.allowsNRVO())
5229 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5230 Constructor, /*Elidable=*/true,
5232 HadMultipleCandidates,
5233 IsListInitialization,
5234 ConstructorInitRequiresZeroInit,
5238 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(),
5241 HadMultipleCandidates,
5242 IsListInitialization,
5243 ConstructorInitRequiresZeroInit,
5247 if (CurInit.isInvalid())
5250 // Only check access if all of that succeeded.
5251 S.CheckConstructorAccess(Loc, Constructor, Entity,
5252 Step.Function.FoundDecl.getAccess());
5253 if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc))
5256 if (shouldBindAsTemporary(Entity))
5257 CurInit = S.MaybeBindToTemporary(CurInit.take());
5262 /// Determine whether the specified InitializedEntity definitely has a lifetime
5263 /// longer than the current full-expression. Conservatively returns false if
5266 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) {
5267 const InitializedEntity *Top = &Entity;
5268 while (Top->getParent())
5269 Top = Top->getParent();
5271 switch (Top->getKind()) {
5272 case InitializedEntity::EK_Variable:
5273 case InitializedEntity::EK_Result:
5274 case InitializedEntity::EK_Exception:
5275 case InitializedEntity::EK_Member:
5276 case InitializedEntity::EK_New:
5277 case InitializedEntity::EK_Base:
5278 case InitializedEntity::EK_Delegating:
5281 case InitializedEntity::EK_ArrayElement:
5282 case InitializedEntity::EK_VectorElement:
5283 case InitializedEntity::EK_BlockElement:
5284 case InitializedEntity::EK_ComplexElement:
5285 // Could not determine what the full initialization is. Assume it might not
5286 // outlive the full-expression.
5289 case InitializedEntity::EK_Parameter:
5290 case InitializedEntity::EK_Parameter_CF_Audited:
5291 case InitializedEntity::EK_Temporary:
5292 case InitializedEntity::EK_LambdaCapture:
5293 case InitializedEntity::EK_CompoundLiteralInit:
5294 case InitializedEntity::EK_RelatedResult:
5295 // The entity being initialized might not outlive the full-expression.
5299 llvm_unreachable("unknown entity kind");
5302 /// Determine the declaration which an initialized entity ultimately refers to,
5303 /// for the purpose of lifetime-extending a temporary bound to a reference in
5304 /// the initialization of \p Entity.
5305 static const ValueDecl *
5306 getDeclForTemporaryLifetimeExtension(const InitializedEntity &Entity,
5307 const ValueDecl *FallbackDecl = 0) {
5308 // C++11 [class.temporary]p5:
5309 switch (Entity.getKind()) {
5310 case InitializedEntity::EK_Variable:
5311 // The temporary [...] persists for the lifetime of the reference
5312 return Entity.getDecl();
5314 case InitializedEntity::EK_Member:
5315 // For subobjects, we look at the complete object.
5316 if (Entity.getParent())
5317 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5321 // -- A temporary bound to a reference member in a constructor's
5322 // ctor-initializer persists until the constructor exits.
5323 return Entity.getDecl();
5325 case InitializedEntity::EK_Parameter:
5326 case InitializedEntity::EK_Parameter_CF_Audited:
5327 // -- A temporary bound to a reference parameter in a function call
5328 // persists until the completion of the full-expression containing
5330 case InitializedEntity::EK_Result:
5331 // -- The lifetime of a temporary bound to the returned value in a
5332 // function return statement is not extended; the temporary is
5333 // destroyed at the end of the full-expression in the return statement.
5334 case InitializedEntity::EK_New:
5335 // -- A temporary bound to a reference in a new-initializer persists
5336 // until the completion of the full-expression containing the
5340 case InitializedEntity::EK_Temporary:
5341 case InitializedEntity::EK_CompoundLiteralInit:
5342 case InitializedEntity::EK_RelatedResult:
5343 // We don't yet know the storage duration of the surrounding temporary.
5344 // Assume it's got full-expression duration for now, it will patch up our
5345 // storage duration if that's not correct.
5348 case InitializedEntity::EK_ArrayElement:
5349 // For subobjects, we look at the complete object.
5350 return getDeclForTemporaryLifetimeExtension(*Entity.getParent(),
5353 case InitializedEntity::EK_Base:
5354 case InitializedEntity::EK_Delegating:
5355 // We can reach this case for aggregate initialization in a constructor:
5356 // struct A { int &&r; };
5357 // struct B : A { B() : A{0} {} };
5358 // In this case, use the innermost field decl as the context.
5359 return FallbackDecl;
5361 case InitializedEntity::EK_BlockElement:
5362 case InitializedEntity::EK_LambdaCapture:
5363 case InitializedEntity::EK_Exception:
5364 case InitializedEntity::EK_VectorElement:
5365 case InitializedEntity::EK_ComplexElement:
5368 llvm_unreachable("unknown entity kind");
5371 static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD);
5373 /// Update a glvalue expression that is used as the initializer of a reference
5374 /// to note that its lifetime is extended.
5375 /// \return \c true if any temporary had its lifetime extended.
5376 static bool performReferenceExtension(Expr *Init, const ValueDecl *ExtendingD) {
5377 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5378 if (ILE->getNumInits() == 1 && ILE->isGLValue()) {
5379 // This is just redundant braces around an initializer. Step over it.
5380 Init = ILE->getInit(0);
5384 // Walk past any constructs which we can lifetime-extend across.
5389 // Step over any subobject adjustments; we may have a materialized
5390 // temporary inside them.
5391 SmallVector<const Expr *, 2> CommaLHSs;
5392 SmallVector<SubobjectAdjustment, 2> Adjustments;
5393 Init = const_cast<Expr *>(
5394 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5396 // Per current approach for DR1376, look through casts to reference type
5397 // when performing lifetime extension.
5398 if (CastExpr *CE = dyn_cast<CastExpr>(Init))
5399 if (CE->getSubExpr()->isGLValue())
5400 Init = CE->getSubExpr();
5402 // FIXME: Per DR1213, subscripting on an array temporary produces an xvalue.
5403 // It's unclear if binding a reference to that xvalue extends the array
5405 } while (Init != Old);
5407 if (MaterializeTemporaryExpr *ME = dyn_cast<MaterializeTemporaryExpr>(Init)) {
5408 // Update the storage duration of the materialized temporary.
5409 // FIXME: Rebuild the expression instead of mutating it.
5410 ME->setExtendingDecl(ExtendingD);
5411 performLifetimeExtension(ME->GetTemporaryExpr(), ExtendingD);
5418 /// Update a prvalue expression that is going to be materialized as a
5419 /// lifetime-extended temporary.
5420 static void performLifetimeExtension(Expr *Init, const ValueDecl *ExtendingD) {
5421 // Dig out the expression which constructs the extended temporary.
5422 SmallVector<const Expr *, 2> CommaLHSs;
5423 SmallVector<SubobjectAdjustment, 2> Adjustments;
5424 Init = const_cast<Expr *>(
5425 Init->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
5427 if (CXXBindTemporaryExpr *BTE = dyn_cast<CXXBindTemporaryExpr>(Init))
5428 Init = BTE->getSubExpr();
5430 if (CXXStdInitializerListExpr *ILE =
5431 dyn_cast<CXXStdInitializerListExpr>(Init)) {
5432 performReferenceExtension(ILE->getSubExpr(), ExtendingD);
5436 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Init)) {
5437 if (ILE->getType()->isArrayType()) {
5438 for (unsigned I = 0, N = ILE->getNumInits(); I != N; ++I)
5439 performLifetimeExtension(ILE->getInit(I), ExtendingD);
5443 if (CXXRecordDecl *RD = ILE->getType()->getAsCXXRecordDecl()) {
5444 assert(RD->isAggregate() && "aggregate init on non-aggregate");
5446 // If we lifetime-extend a braced initializer which is initializing an
5447 // aggregate, and that aggregate contains reference members which are
5448 // bound to temporaries, those temporaries are also lifetime-extended.
5449 if (RD->isUnion() && ILE->getInitializedFieldInUnion() &&
5450 ILE->getInitializedFieldInUnion()->getType()->isReferenceType())
5451 performReferenceExtension(ILE->getInit(0), ExtendingD);
5454 for (RecordDecl::field_iterator I = RD->field_begin(),
5455 E = RD->field_end();
5457 if (Index >= ILE->getNumInits())
5459 if (I->isUnnamedBitfield())
5461 Expr *SubInit = ILE->getInit(Index);
5462 if (I->getType()->isReferenceType())
5463 performReferenceExtension(SubInit, ExtendingD);
5464 else if (isa<InitListExpr>(SubInit) ||
5465 isa<CXXStdInitializerListExpr>(SubInit))
5466 // This may be either aggregate-initialization of a member or
5467 // initialization of a std::initializer_list object. Either way,
5468 // we should recursively lifetime-extend that initializer.
5469 performLifetimeExtension(SubInit, ExtendingD);
5477 static void warnOnLifetimeExtension(Sema &S, const InitializedEntity &Entity,
5478 const Expr *Init, bool IsInitializerList,
5479 const ValueDecl *ExtendingDecl) {
5480 // Warn if a field lifetime-extends a temporary.
5481 if (isa<FieldDecl>(ExtendingDecl)) {
5482 if (IsInitializerList) {
5483 S.Diag(Init->getExprLoc(), diag::warn_dangling_std_initializer_list)
5484 << /*at end of constructor*/true;
5488 bool IsSubobjectMember = false;
5489 for (const InitializedEntity *Ent = Entity.getParent(); Ent;
5490 Ent = Ent->getParent()) {
5491 if (Ent->getKind() != InitializedEntity::EK_Base) {
5492 IsSubobjectMember = true;
5496 S.Diag(Init->getExprLoc(),
5497 diag::warn_bind_ref_member_to_temporary)
5498 << ExtendingDecl << Init->getSourceRange()
5499 << IsSubobjectMember << IsInitializerList;
5500 if (IsSubobjectMember)
5501 S.Diag(ExtendingDecl->getLocation(),
5502 diag::note_ref_subobject_of_member_declared_here);
5504 S.Diag(ExtendingDecl->getLocation(),
5505 diag::note_ref_or_ptr_member_declared_here)
5506 << /*is pointer*/false;
5510 static void DiagnoseNarrowingInInitList(Sema &S,
5511 const ImplicitConversionSequence &ICS,
5512 QualType PreNarrowingType,
5513 QualType EntityType,
5514 const Expr *PostInit);
5517 InitializationSequence::Perform(Sema &S,
5518 const InitializedEntity &Entity,
5519 const InitializationKind &Kind,
5521 QualType *ResultType) {
5523 Diagnose(S, Entity, Kind, Args);
5527 if (getKind() == DependentSequence) {
5528 // If the declaration is a non-dependent, incomplete array type
5529 // that has an initializer, then its type will be completed once
5530 // the initializer is instantiated.
5531 if (ResultType && !Entity.getType()->isDependentType() &&
5533 QualType DeclType = Entity.getType();
5534 if (const IncompleteArrayType *ArrayT
5535 = S.Context.getAsIncompleteArrayType(DeclType)) {
5536 // FIXME: We don't currently have the ability to accurately
5537 // compute the length of an initializer list without
5538 // performing full type-checking of the initializer list
5539 // (since we have to determine where braces are implicitly
5540 // introduced and such). So, we fall back to making the array
5541 // type a dependently-sized array type with no specified
5543 if (isa<InitListExpr>((Expr *)Args[0])) {
5544 SourceRange Brackets;
5546 // Scavange the location of the brackets from the entity, if we can.
5547 if (DeclaratorDecl *DD = Entity.getDecl()) {
5548 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) {
5549 TypeLoc TL = TInfo->getTypeLoc();
5550 if (IncompleteArrayTypeLoc ArrayLoc =
5551 TL.getAs<IncompleteArrayTypeLoc>())
5552 Brackets = ArrayLoc.getBracketsRange();
5557 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(),
5559 ArrayT->getSizeModifier(),
5560 ArrayT->getIndexTypeCVRQualifiers(),
5566 if (Kind.getKind() == InitializationKind::IK_Direct &&
5567 !Kind.isExplicitCast()) {
5568 // Rebuild the ParenListExpr.
5569 SourceRange ParenRange = Kind.getParenRange();
5570 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(),
5573 assert(Kind.getKind() == InitializationKind::IK_Copy ||
5574 Kind.isExplicitCast() ||
5575 Kind.getKind() == InitializationKind::IK_DirectList);
5576 return ExprResult(Args[0]);
5579 // No steps means no initialization.
5581 return S.Owned((Expr *)0);
5583 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() &&
5584 Args.size() == 1 && isa<InitListExpr>(Args[0]) &&
5585 !Entity.isParameterKind()) {
5586 // Produce a C++98 compatibility warning if we are initializing a reference
5587 // from an initializer list. For parameters, we produce a better warning
5589 Expr *Init = Args[0];
5590 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init)
5591 << Init->getSourceRange();
5594 // Diagnose cases where we initialize a pointer to an array temporary, and the
5595 // pointer obviously outlives the temporary.
5596 if (Args.size() == 1 && Args[0]->getType()->isArrayType() &&
5597 Entity.getType()->isPointerType() &&
5598 InitializedEntityOutlivesFullExpression(Entity)) {
5599 Expr *Init = Args[0];
5600 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context);
5601 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary)
5602 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay)
5603 << Init->getSourceRange();
5606 QualType DestType = Entity.getType().getNonReferenceType();
5607 // FIXME: Ugly hack around the fact that Entity.getType() is not
5608 // the same as Entity.getDecl()->getType() in cases involving type merging,
5609 // and we want latter when it makes sense.
5611 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() :
5614 ExprResult CurInit = S.Owned((Expr *)0);
5616 // For initialization steps that start with a single initializer,
5617 // grab the only argument out the Args and place it into the "current"
5619 switch (Steps.front().Kind) {
5620 case SK_ResolveAddressOfOverloadedFunction:
5621 case SK_CastDerivedToBaseRValue:
5622 case SK_CastDerivedToBaseXValue:
5623 case SK_CastDerivedToBaseLValue:
5624 case SK_BindReference:
5625 case SK_BindReferenceToTemporary:
5626 case SK_ExtraneousCopyToTemporary:
5627 case SK_UserConversion:
5628 case SK_QualificationConversionLValue:
5629 case SK_QualificationConversionXValue:
5630 case SK_QualificationConversionRValue:
5631 case SK_LValueToRValue:
5632 case SK_ConversionSequence:
5633 case SK_ConversionSequenceNoNarrowing:
5634 case SK_ListInitialization:
5635 case SK_UnwrapInitList:
5636 case SK_RewrapInitList:
5637 case SK_CAssignment:
5639 case SK_ObjCObjectConversion:
5641 case SK_ParenthesizedArrayInit:
5642 case SK_PassByIndirectCopyRestore:
5643 case SK_PassByIndirectRestore:
5644 case SK_ProduceObjCObject:
5645 case SK_StdInitializerList:
5646 case SK_OCLSamplerInit:
5647 case SK_OCLZeroEvent: {
5648 assert(Args.size() == 1);
5650 if (!CurInit.get()) return ExprError();
5654 case SK_ConstructorInitialization:
5655 case SK_ListConstructorCall:
5656 case SK_ZeroInitialization:
5660 // Walk through the computed steps for the initialization sequence,
5661 // performing the specified conversions along the way.
5662 bool ConstructorInitRequiresZeroInit = false;
5663 for (step_iterator Step = step_begin(), StepEnd = step_end();
5664 Step != StepEnd; ++Step) {
5665 if (CurInit.isInvalid())
5668 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType();
5670 switch (Step->Kind) {
5671 case SK_ResolveAddressOfOverloadedFunction:
5672 // Overload resolution determined which function invoke; update the
5673 // initializer to reflect that choice.
5674 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl);
5675 if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()))
5677 CurInit = S.FixOverloadedFunctionReference(CurInit,
5678 Step->Function.FoundDecl,
5679 Step->Function.Function);
5682 case SK_CastDerivedToBaseRValue:
5683 case SK_CastDerivedToBaseXValue:
5684 case SK_CastDerivedToBaseLValue: {
5685 // We have a derived-to-base cast that produces either an rvalue or an
5686 // lvalue. Perform that cast.
5688 CXXCastPath BasePath;
5690 // Casts to inaccessible base classes are allowed with C-style casts.
5691 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast();
5692 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type,
5693 CurInit.get()->getLocStart(),
5694 CurInit.get()->getSourceRange(),
5695 &BasePath, IgnoreBaseAccess))
5698 if (S.BasePathInvolvesVirtualBase(BasePath)) {
5699 QualType T = SourceType;
5700 if (const PointerType *Pointer = T->getAs<PointerType>())
5701 T = Pointer->getPointeeType();
5702 if (const RecordType *RecordTy = T->getAs<RecordType>())
5703 S.MarkVTableUsed(CurInit.get()->getLocStart(),
5704 cast<CXXRecordDecl>(RecordTy->getDecl()));
5708 Step->Kind == SK_CastDerivedToBaseLValue ?
5710 (Step->Kind == SK_CastDerivedToBaseXValue ?
5713 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5721 case SK_BindReference:
5722 // References cannot bind to bit-fields (C++ [dcl.init.ref]p5).
5723 if (CurInit.get()->refersToBitField()) {
5724 // We don't necessarily have an unambiguous source bit-field.
5725 FieldDecl *BitField = CurInit.get()->getSourceBitField();
5726 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield)
5727 << Entity.getType().isVolatileQualified()
5728 << (BitField ? BitField->getDeclName() : DeclarationName())
5729 << (BitField != NULL)
5730 << CurInit.get()->getSourceRange();
5732 S.Diag(BitField->getLocation(), diag::note_bitfield_decl);
5737 if (CurInit.get()->refersToVectorElement()) {
5738 // References cannot bind to vector elements.
5739 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element)
5740 << Entity.getType().isVolatileQualified()
5741 << CurInit.get()->getSourceRange();
5742 PrintInitLocationNote(S, Entity);
5746 // Reference binding does not have any corresponding ASTs.
5748 // Check exception specifications
5749 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
5752 // Even though we didn't materialize a temporary, the binding may still
5753 // extend the lifetime of a temporary. This happens if we bind a reference
5754 // to the result of a cast to reference type.
5755 if (const ValueDecl *ExtendingDecl =
5756 getDeclForTemporaryLifetimeExtension(Entity)) {
5757 if (performReferenceExtension(CurInit.get(), ExtendingDecl))
5758 warnOnLifetimeExtension(S, Entity, CurInit.get(), false,
5764 case SK_BindReferenceToTemporary: {
5765 // Make sure the "temporary" is actually an rvalue.
5766 assert(CurInit.get()->isRValue() && "not a temporary");
5768 // Check exception specifications
5769 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
5772 // Maybe lifetime-extend the temporary's subobjects to match the
5773 // entity's lifetime.
5774 const ValueDecl *ExtendingDecl =
5775 getDeclForTemporaryLifetimeExtension(Entity);
5776 if (ExtendingDecl) {
5777 performLifetimeExtension(CurInit.get(), ExtendingDecl);
5778 warnOnLifetimeExtension(S, Entity, CurInit.get(), false, ExtendingDecl);
5781 // Materialize the temporary into memory.
5782 MaterializeTemporaryExpr *MTE = new (S.Context) MaterializeTemporaryExpr(
5783 Entity.getType().getNonReferenceType(), CurInit.get(),
5784 Entity.getType()->isLValueReferenceType(), ExtendingDecl);
5786 // If we're binding to an Objective-C object that has lifetime, we
5787 // need cleanups. Likewise if we're extending this temporary to automatic
5788 // storage duration -- we need to register its cleanup during the
5789 // full-expression's cleanups.
5790 if ((S.getLangOpts().ObjCAutoRefCount &&
5791 MTE->getType()->isObjCLifetimeType()) ||
5792 (MTE->getStorageDuration() == SD_Automatic &&
5793 MTE->getType().isDestructedType()))
5794 S.ExprNeedsCleanups = true;
5796 CurInit = S.Owned(MTE);
5800 case SK_ExtraneousCopyToTemporary:
5801 CurInit = CopyObject(S, Step->Type, Entity, CurInit,
5802 /*IsExtraneousCopy=*/true);
5805 case SK_UserConversion: {
5806 // We have a user-defined conversion that invokes either a constructor
5807 // or a conversion function.
5809 bool IsCopy = false;
5810 FunctionDecl *Fn = Step->Function.Function;
5811 DeclAccessPair FoundFn = Step->Function.FoundDecl;
5812 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates;
5813 bool CreatedObject = false;
5814 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
5815 // Build a call to the selected constructor.
5816 SmallVector<Expr*, 8> ConstructorArgs;
5817 SourceLocation Loc = CurInit.get()->getLocStart();
5818 CurInit.release(); // Ownership transferred into MultiExprArg, below.
5820 // Determine the arguments required to actually perform the constructor
5822 Expr *Arg = CurInit.get();
5823 if (S.CompleteConstructorCall(Constructor,
5824 MultiExprArg(&Arg, 1),
5825 Loc, ConstructorArgs))
5828 // Build an expression that constructs a temporary.
5829 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor,
5831 HadMultipleCandidates,
5834 CXXConstructExpr::CK_Complete,
5836 if (CurInit.isInvalid())
5839 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity,
5840 FoundFn.getAccess());
5841 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5844 CastKind = CK_ConstructorConversion;
5845 QualType Class = S.Context.getTypeDeclType(Constructor->getParent());
5846 if (S.Context.hasSameUnqualifiedType(SourceType, Class) ||
5847 S.IsDerivedFrom(SourceType, Class))
5850 CreatedObject = true;
5852 // Build a call to the conversion function.
5853 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn);
5854 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), 0,
5856 if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()))
5859 // FIXME: Should we move this initialization into a separate
5860 // derived-to-base conversion? I believe the answer is "no", because
5861 // we don't want to turn off access control here for c-style casts.
5862 ExprResult CurInitExprRes =
5863 S.PerformObjectArgumentInitialization(CurInit.take(), /*Qualifier=*/0,
5864 FoundFn, Conversion);
5865 if(CurInitExprRes.isInvalid())
5867 CurInit = CurInitExprRes;
5869 // Build the actual call to the conversion function.
5870 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion,
5871 HadMultipleCandidates);
5872 if (CurInit.isInvalid() || !CurInit.get())
5875 CastKind = CK_UserDefinedConversion;
5877 CreatedObject = Conversion->getResultType()->isRecordType();
5880 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back());
5881 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity);
5883 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) {
5884 QualType T = CurInit.get()->getType();
5885 if (const RecordType *Record = T->getAs<RecordType>()) {
5886 CXXDestructorDecl *Destructor
5887 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl()));
5888 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor,
5889 S.PDiag(diag::err_access_dtor_temp) << T);
5890 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor);
5891 if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()))
5896 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context,
5897 CurInit.get()->getType(),
5898 CastKind, CurInit.get(), 0,
5899 CurInit.get()->getValueKind()));
5900 if (MaybeBindToTemp)
5901 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>());
5903 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity,
5904 CurInit, /*IsExtraneousCopy=*/false);
5908 case SK_QualificationConversionLValue:
5909 case SK_QualificationConversionXValue:
5910 case SK_QualificationConversionRValue: {
5911 // Perform a qualification conversion; these can never go wrong.
5913 Step->Kind == SK_QualificationConversionLValue ?
5915 (Step->Kind == SK_QualificationConversionXValue ?
5918 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK);
5922 case SK_LValueToRValue: {
5923 assert(CurInit.get()->isGLValue() && "cannot load from a prvalue");
5924 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
5932 case SK_ConversionSequence:
5933 case SK_ConversionSequenceNoNarrowing: {
5934 Sema::CheckedConversionKind CCK
5935 = Kind.isCStyleCast()? Sema::CCK_CStyleCast
5936 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast
5937 : Kind.isExplicitCast()? Sema::CCK_OtherCast
5938 : Sema::CCK_ImplicitConversion;
5939 ExprResult CurInitExprRes =
5940 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS,
5941 getAssignmentAction(Entity), CCK);
5942 if (CurInitExprRes.isInvalid())
5944 CurInit = CurInitExprRes;
5946 if (Step->Kind == SK_ConversionSequenceNoNarrowing &&
5947 S.getLangOpts().CPlusPlus && !CurInit.get()->isValueDependent())
5948 DiagnoseNarrowingInInitList(S, *Step->ICS, SourceType, Entity.getType(),
5953 case SK_ListInitialization: {
5954 InitListExpr *InitList = cast<InitListExpr>(CurInit.get());
5955 // If we're not initializing the top-level entity, we need to create an
5956 // InitializeTemporary entity for our target type.
5957 QualType Ty = Step->Type;
5958 bool IsTemporary = !S.Context.hasSameType(Entity.getType(), Ty);
5959 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty);
5960 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity;
5961 InitListChecker PerformInitList(S, InitEntity,
5962 InitList, Ty, /*VerifyOnly=*/false);
5963 if (PerformInitList.HadError())
5966 // Hack: We must update *ResultType if available in order to set the
5967 // bounds of arrays, e.g. in 'int ar[] = {1, 2, 3};'.
5968 // Worst case: 'const int (&arref)[] = {1, 2, 3};'.
5970 ResultType->getNonReferenceType()->isIncompleteArrayType()) {
5971 if ((*ResultType)->isRValueReferenceType())
5972 Ty = S.Context.getRValueReferenceType(Ty);
5973 else if ((*ResultType)->isLValueReferenceType())
5974 Ty = S.Context.getLValueReferenceType(Ty,
5975 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue());
5979 InitListExpr *StructuredInitList =
5980 PerformInitList.getFullyStructuredList();
5982 CurInit = shouldBindAsTemporary(InitEntity)
5983 ? S.MaybeBindToTemporary(StructuredInitList)
5984 : S.Owned(StructuredInitList);
5988 case SK_ListConstructorCall: {
5989 // When an initializer list is passed for a parameter of type "reference
5990 // to object", we don't get an EK_Temporary entity, but instead an
5991 // EK_Parameter entity with reference type.
5992 // FIXME: This is a hack. What we really should do is create a user
5993 // conversion step for this case, but this makes it considerably more
5994 // complicated. For now, this will do.
5995 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
5996 Entity.getType().getNonReferenceType());
5997 bool UseTemporary = Entity.getType()->isReferenceType();
5998 assert(Args.size() == 1 && "expected a single argument for list init");
5999 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6000 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init)
6001 << InitList->getSourceRange();
6002 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits());
6003 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity :
6006 ConstructorInitRequiresZeroInit,
6007 /*IsListInitialization*/ true,
6008 InitList->getLBraceLoc(),
6009 InitList->getRBraceLoc());
6013 case SK_UnwrapInitList:
6014 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0));
6017 case SK_RewrapInitList: {
6018 Expr *E = CurInit.take();
6019 InitListExpr *Syntactic = Step->WrappingSyntacticList;
6020 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context,
6021 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc());
6022 ILE->setSyntacticForm(Syntactic);
6023 ILE->setType(E->getType());
6024 ILE->setValueKind(E->getValueKind());
6025 CurInit = S.Owned(ILE);
6029 case SK_ConstructorInitialization: {
6030 // When an initializer list is passed for a parameter of type "reference
6031 // to object", we don't get an EK_Temporary entity, but instead an
6032 // EK_Parameter entity with reference type.
6033 // FIXME: This is a hack. What we really should do is create a user
6034 // conversion step for this case, but this makes it considerably more
6035 // complicated. For now, this will do.
6036 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(
6037 Entity.getType().getNonReferenceType());
6038 bool UseTemporary = Entity.getType()->isReferenceType();
6039 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity
6042 ConstructorInitRequiresZeroInit,
6043 /*IsListInitialization*/ false,
6044 /*LBraceLoc*/ SourceLocation(),
6045 /*RBraceLoc*/ SourceLocation());
6049 case SK_ZeroInitialization: {
6050 step_iterator NextStep = Step;
6052 if (NextStep != StepEnd &&
6053 (NextStep->Kind == SK_ConstructorInitialization ||
6054 NextStep->Kind == SK_ListConstructorCall)) {
6055 // The need for zero-initialization is recorded directly into
6056 // the call to the object's constructor within the next step.
6057 ConstructorInitRequiresZeroInit = true;
6058 } else if (Kind.getKind() == InitializationKind::IK_Value &&
6059 S.getLangOpts().CPlusPlus &&
6060 !Kind.isImplicitValueInit()) {
6061 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
6063 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type,
6064 Kind.getRange().getBegin());
6066 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr(
6067 TSInfo->getType().getNonLValueExprType(S.Context),
6069 Kind.getRange().getEnd()));
6071 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type));
6076 case SK_CAssignment: {
6077 QualType SourceType = CurInit.get()->getType();
6078 ExprResult Result = CurInit;
6079 Sema::AssignConvertType ConvTy =
6080 S.CheckSingleAssignmentConstraints(Step->Type, Result, true,
6081 Entity.getKind() == InitializedEntity::EK_Parameter_CF_Audited);
6082 if (Result.isInvalid())
6086 // If this is a call, allow conversion to a transparent union.
6087 ExprResult CurInitExprRes = CurInit;
6088 if (ConvTy != Sema::Compatible &&
6089 Entity.isParameterKind() &&
6090 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes)
6091 == Sema::Compatible)
6092 ConvTy = Sema::Compatible;
6093 if (CurInitExprRes.isInvalid())
6095 CurInit = CurInitExprRes;
6098 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(),
6099 Step->Type, SourceType,
6101 getAssignmentAction(Entity, true),
6103 PrintInitLocationNote(S, Entity);
6105 } else if (Complained)
6106 PrintInitLocationNote(S, Entity);
6110 case SK_StringInit: {
6111 QualType Ty = Step->Type;
6112 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty,
6113 S.Context.getAsArrayType(Ty), S);
6117 case SK_ObjCObjectConversion:
6118 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
6119 CK_ObjCObjectLValueCast,
6120 CurInit.get()->getValueKind());
6124 // Okay: we checked everything before creating this step. Note that
6125 // this is a GNU extension.
6126 S.Diag(Kind.getLocation(), diag::ext_array_init_copy)
6127 << Step->Type << CurInit.get()->getType()
6128 << CurInit.get()->getSourceRange();
6130 // If the destination type is an incomplete array type, update the
6131 // type accordingly.
6133 if (const IncompleteArrayType *IncompleteDest
6134 = S.Context.getAsIncompleteArrayType(Step->Type)) {
6135 if (const ConstantArrayType *ConstantSource
6136 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) {
6137 *ResultType = S.Context.getConstantArrayType(
6138 IncompleteDest->getElementType(),
6139 ConstantSource->getSize(),
6140 ArrayType::Normal, 0);
6146 case SK_ParenthesizedArrayInit:
6147 // Okay: we checked everything before creating this step. Note that
6148 // this is a GNU extension.
6149 S.Diag(Kind.getLocation(), diag::ext_array_init_parens)
6150 << CurInit.get()->getSourceRange();
6153 case SK_PassByIndirectCopyRestore:
6154 case SK_PassByIndirectRestore:
6155 checkIndirectCopyRestoreSource(S, CurInit.get());
6156 CurInit = S.Owned(new (S.Context)
6157 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type,
6158 Step->Kind == SK_PassByIndirectCopyRestore));
6161 case SK_ProduceObjCObject:
6162 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type,
6163 CK_ARCProduceObject,
6164 CurInit.take(), 0, VK_RValue));
6167 case SK_StdInitializerList: {
6168 S.Diag(CurInit.get()->getExprLoc(),
6169 diag::warn_cxx98_compat_initializer_list_init)
6170 << CurInit.get()->getSourceRange();
6172 // Maybe lifetime-extend the array temporary's subobjects to match the
6173 // entity's lifetime.
6174 const ValueDecl *ExtendingDecl =
6175 getDeclForTemporaryLifetimeExtension(Entity);
6176 if (ExtendingDecl) {
6177 performLifetimeExtension(CurInit.get(), ExtendingDecl);
6178 warnOnLifetimeExtension(S, Entity, CurInit.get(), true, ExtendingDecl);
6181 // Materialize the temporary into memory.
6182 MaterializeTemporaryExpr *MTE = new (S.Context)
6183 MaterializeTemporaryExpr(CurInit.get()->getType(), CurInit.get(),
6184 /*lvalue reference*/ false, ExtendingDecl);
6186 // Wrap it in a construction of a std::initializer_list<T>.
6188 new (S.Context) CXXStdInitializerListExpr(Step->Type, MTE));
6190 // Bind the result, in case the library has given initializer_list a
6191 // non-trivial destructor.
6192 if (shouldBindAsTemporary(Entity))
6193 CurInit = S.MaybeBindToTemporary(CurInit.take());
6197 case SK_OCLSamplerInit: {
6198 assert(Step->Type->isSamplerT() &&
6199 "Sampler initialization on non sampler type.");
6201 QualType SourceType = CurInit.get()->getType();
6203 if (Entity.isParameterKind()) {
6204 if (!SourceType->isSamplerT())
6205 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
6207 } else if (Entity.getKind() != InitializedEntity::EK_Variable) {
6208 llvm_unreachable("Invalid EntityKind!");
6213 case SK_OCLZeroEvent: {
6214 assert(Step->Type->isEventT() &&
6215 "Event initialization on non event type.");
6217 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type,
6219 CurInit.get()->getValueKind());
6225 // Diagnose non-fatal problems with the completed initialization.
6226 if (Entity.getKind() == InitializedEntity::EK_Member &&
6227 cast<FieldDecl>(Entity.getDecl())->isBitField())
6228 S.CheckBitFieldInitialization(Kind.getLocation(),
6229 cast<FieldDecl>(Entity.getDecl()),
6235 /// Somewhere within T there is an uninitialized reference subobject.
6236 /// Dig it out and diagnose it.
6237 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc,
6239 if (T->isReferenceType()) {
6240 S.Diag(Loc, diag::err_reference_without_init)
6241 << T.getNonReferenceType();
6245 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
6246 if (!RD || !RD->hasUninitializedReferenceMember())
6249 for (CXXRecordDecl::field_iterator FI = RD->field_begin(),
6250 FE = RD->field_end(); FI != FE; ++FI) {
6251 if (FI->isUnnamedBitfield())
6254 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {
6255 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6260 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(),
6261 BE = RD->bases_end();
6263 if (DiagnoseUninitializedReference(S, BI->getLocStart(), BI->getType())) {
6264 S.Diag(Loc, diag::note_value_initialization_here) << RD;
6273 //===----------------------------------------------------------------------===//
6274 // Diagnose initialization failures
6275 //===----------------------------------------------------------------------===//
6277 /// Emit notes associated with an initialization that failed due to a
6278 /// "simple" conversion failure.
6279 static void emitBadConversionNotes(Sema &S, const InitializedEntity &entity,
6281 QualType destType = entity.getType();
6282 if (destType.getNonReferenceType()->isObjCObjectPointerType() &&
6283 op->getType()->isObjCObjectPointerType()) {
6285 // Emit a possible note about the conversion failing because the
6286 // operand is a message send with a related result type.
6287 S.EmitRelatedResultTypeNote(op);
6289 // Emit a possible note about a return failing because we're
6290 // expecting a related result type.
6291 if (entity.getKind() == InitializedEntity::EK_Result)
6292 S.EmitRelatedResultTypeNoteForReturn(destType);
6296 static void diagnoseListInit(Sema &S, const InitializedEntity &Entity,
6297 InitListExpr *InitList) {
6298 QualType DestType = Entity.getType();
6301 if (S.getLangOpts().CPlusPlus11 && S.isStdInitializerList(DestType, &E)) {
6302 QualType ArrayType = S.Context.getConstantArrayType(
6304 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()),
6305 InitList->getNumInits()),
6306 clang::ArrayType::Normal, 0);
6307 InitializedEntity HiddenArray =
6308 InitializedEntity::InitializeTemporary(ArrayType);
6309 return diagnoseListInit(S, HiddenArray, InitList);
6312 if (DestType->isReferenceType()) {
6313 // A list-initialization failure for a reference means that we tried to
6314 // create a temporary of the inner type (per [dcl.init.list]p3.6) and the
6315 // inner initialization failed.
6316 QualType T = DestType->getAs<ReferenceType>()->getPointeeType();
6317 diagnoseListInit(S, InitializedEntity::InitializeTemporary(T), InitList);
6318 SourceLocation Loc = InitList->getLocStart();
6319 if (DeclaratorDecl *D = Entity.getDecl())
6320 Loc = D->getLocation();
6321 S.Diag(Loc, diag::note_in_reference_temporary_list_initializer) << T;
6325 InitListChecker DiagnoseInitList(S, Entity, InitList, DestType,
6326 /*VerifyOnly=*/false);
6327 assert(DiagnoseInitList.HadError() &&
6328 "Inconsistent init list check result.");
6331 bool InitializationSequence::Diagnose(Sema &S,
6332 const InitializedEntity &Entity,
6333 const InitializationKind &Kind,
6334 ArrayRef<Expr *> Args) {
6338 QualType DestType = Entity.getType();
6340 case FK_TooManyInitsForReference:
6341 // FIXME: Customize for the initialized entity?
6343 // Dig out the reference subobject which is uninitialized and diagnose it.
6344 // If this is value-initialization, this could be nested some way within
6346 assert(Kind.getKind() == InitializationKind::IK_Value ||
6347 DestType->isReferenceType());
6349 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType);
6350 assert(Diagnosed && "couldn't find uninitialized reference to diagnose");
6352 } else // FIXME: diagnostic below could be better!
6353 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits)
6354 << SourceRange(Args.front()->getLocStart(), Args.back()->getLocEnd());
6357 case FK_ArrayNeedsInitList:
6358 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 0;
6360 case FK_ArrayNeedsInitListOrStringLiteral:
6361 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 1;
6363 case FK_ArrayNeedsInitListOrWideStringLiteral:
6364 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) << 2;
6366 case FK_NarrowStringIntoWideCharArray:
6367 S.Diag(Kind.getLocation(), diag::err_array_init_narrow_string_into_wchar);
6369 case FK_WideStringIntoCharArray:
6370 S.Diag(Kind.getLocation(), diag::err_array_init_wide_string_into_char);
6372 case FK_IncompatWideStringIntoWideChar:
6373 S.Diag(Kind.getLocation(),
6374 diag::err_array_init_incompat_wide_string_into_wchar);
6376 case FK_ArrayTypeMismatch:
6377 case FK_NonConstantArrayInit:
6378 S.Diag(Kind.getLocation(),
6379 (Failure == FK_ArrayTypeMismatch
6380 ? diag::err_array_init_different_type
6381 : diag::err_array_init_non_constant_array))
6382 << DestType.getNonReferenceType()
6383 << Args[0]->getType()
6384 << Args[0]->getSourceRange();
6387 case FK_VariableLengthArrayHasInitializer:
6388 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init)
6389 << Args[0]->getSourceRange();
6392 case FK_AddressOfOverloadFailed: {
6393 DeclAccessPair Found;
6394 S.ResolveAddressOfOverloadedFunction(Args[0],
6395 DestType.getNonReferenceType(),
6401 case FK_ReferenceInitOverloadFailed:
6402 case FK_UserConversionOverloadFailed:
6403 switch (FailedOverloadResult) {
6405 if (Failure == FK_UserConversionOverloadFailed)
6406 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition)
6407 << Args[0]->getType() << DestType
6408 << Args[0]->getSourceRange();
6410 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous)
6411 << DestType << Args[0]->getType()
6412 << Args[0]->getSourceRange();
6414 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6417 case OR_No_Viable_Function:
6418 if (!S.RequireCompleteType(Kind.getLocation(),
6419 DestType.getNonReferenceType(),
6420 diag::err_typecheck_nonviable_condition_incomplete,
6421 Args[0]->getType(), Args[0]->getSourceRange()))
6422 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
6423 << Args[0]->getType() << Args[0]->getSourceRange()
6424 << DestType.getNonReferenceType();
6426 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6430 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function)
6431 << Args[0]->getType() << DestType.getNonReferenceType()
6432 << Args[0]->getSourceRange();
6433 OverloadCandidateSet::iterator Best;
6434 OverloadingResult Ovl
6435 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best,
6437 if (Ovl == OR_Deleted) {
6438 S.NoteDeletedFunction(Best->Function);
6440 llvm_unreachable("Inconsistent overload resolution?");
6446 llvm_unreachable("Conversion did not fail!");
6450 case FK_NonConstLValueReferenceBindingToTemporary:
6451 if (isa<InitListExpr>(Args[0])) {
6452 S.Diag(Kind.getLocation(),
6453 diag::err_lvalue_reference_bind_to_initlist)
6454 << DestType.getNonReferenceType().isVolatileQualified()
6455 << DestType.getNonReferenceType()
6456 << Args[0]->getSourceRange();
6459 // Intentional fallthrough
6461 case FK_NonConstLValueReferenceBindingToUnrelated:
6462 S.Diag(Kind.getLocation(),
6463 Failure == FK_NonConstLValueReferenceBindingToTemporary
6464 ? diag::err_lvalue_reference_bind_to_temporary
6465 : diag::err_lvalue_reference_bind_to_unrelated)
6466 << DestType.getNonReferenceType().isVolatileQualified()
6467 << DestType.getNonReferenceType()
6468 << Args[0]->getType()
6469 << Args[0]->getSourceRange();
6472 case FK_RValueReferenceBindingToLValue:
6473 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref)
6474 << DestType.getNonReferenceType() << Args[0]->getType()
6475 << Args[0]->getSourceRange();
6478 case FK_ReferenceInitDropsQualifiers:
6479 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals)
6480 << DestType.getNonReferenceType()
6481 << Args[0]->getType()
6482 << Args[0]->getSourceRange();
6485 case FK_ReferenceInitFailed:
6486 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed)
6487 << DestType.getNonReferenceType()
6488 << Args[0]->isLValue()
6489 << Args[0]->getType()
6490 << Args[0]->getSourceRange();
6491 emitBadConversionNotes(S, Entity, Args[0]);
6494 case FK_ConversionFailed: {
6495 QualType FromType = Args[0]->getType();
6496 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed)
6497 << (int)Entity.getKind()
6499 << Args[0]->isLValue()
6501 << Args[0]->getSourceRange();
6502 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType);
6503 S.Diag(Kind.getLocation(), PDiag);
6504 emitBadConversionNotes(S, Entity, Args[0]);
6508 case FK_ConversionFromPropertyFailed:
6509 // No-op. This error has already been reported.
6512 case FK_TooManyInitsForScalar: {
6515 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0]))
6516 R = SourceRange(InitList->getInit(0)->getLocEnd(),
6517 InitList->getLocEnd());
6519 R = SourceRange(Args.front()->getLocEnd(), Args.back()->getLocEnd());
6521 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin()));
6522 if (Kind.isCStyleOrFunctionalCast())
6523 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg)
6526 S.Diag(Kind.getLocation(), diag::err_excess_initializers)
6527 << /*scalar=*/2 << R;
6531 case FK_ReferenceBindingToInitList:
6532 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list)
6533 << DestType.getNonReferenceType() << Args[0]->getSourceRange();
6536 case FK_InitListBadDestinationType:
6537 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type)
6538 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange();
6541 case FK_ListConstructorOverloadFailed:
6542 case FK_ConstructorOverloadFailed: {
6543 SourceRange ArgsRange;
6545 ArgsRange = SourceRange(Args.front()->getLocStart(),
6546 Args.back()->getLocEnd());
6548 if (Failure == FK_ListConstructorOverloadFailed) {
6549 assert(Args.size() == 1 && "List construction from other than 1 argument.");
6550 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6551 Args = MultiExprArg(InitList->getInits(), InitList->getNumInits());
6554 // FIXME: Using "DestType" for the entity we're printing is probably
6556 switch (FailedOverloadResult) {
6558 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init)
6559 << DestType << ArgsRange;
6560 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args);
6563 case OR_No_Viable_Function:
6564 if (Kind.getKind() == InitializationKind::IK_Default &&
6565 (Entity.getKind() == InitializedEntity::EK_Base ||
6566 Entity.getKind() == InitializedEntity::EK_Member) &&
6567 isa<CXXConstructorDecl>(S.CurContext)) {
6568 // This is implicit default initialization of a member or
6569 // base within a constructor. If no viable function was
6570 // found, notify the user that she needs to explicitly
6571 // initialize this base/member.
6572 CXXConstructorDecl *Constructor
6573 = cast<CXXConstructorDecl>(S.CurContext);
6574 if (Entity.getKind() == InitializedEntity::EK_Base) {
6575 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
6576 << (Constructor->getInheritedConstructor() ? 2 :
6577 Constructor->isImplicit() ? 1 : 0)
6578 << S.Context.getTypeDeclType(Constructor->getParent())
6580 << Entity.getType();
6582 RecordDecl *BaseDecl
6583 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>()
6585 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl)
6586 << S.Context.getTagDeclType(BaseDecl);
6588 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor)
6589 << (Constructor->getInheritedConstructor() ? 2 :
6590 Constructor->isImplicit() ? 1 : 0)
6591 << S.Context.getTypeDeclType(Constructor->getParent())
6593 << Entity.getName();
6594 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl);
6596 if (const RecordType *Record
6597 = Entity.getType()->getAs<RecordType>())
6598 S.Diag(Record->getDecl()->getLocation(),
6599 diag::note_previous_decl)
6600 << S.Context.getTagDeclType(Record->getDecl());
6605 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init)
6606 << DestType << ArgsRange;
6607 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args);
6611 OverloadCandidateSet::iterator Best;
6612 OverloadingResult Ovl
6613 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
6614 if (Ovl != OR_Deleted) {
6615 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6616 << true << DestType << ArgsRange;
6617 llvm_unreachable("Inconsistent overload resolution?");
6621 // If this is a defaulted or implicitly-declared function, then
6622 // it was implicitly deleted. Make it clear that the deletion was
6624 if (S.isImplicitlyDeleted(Best->Function))
6625 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init)
6626 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function))
6627 << DestType << ArgsRange;
6629 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init)
6630 << true << DestType << ArgsRange;
6632 S.NoteDeletedFunction(Best->Function);
6637 llvm_unreachable("Conversion did not fail!");
6642 case FK_DefaultInitOfConst:
6643 if (Entity.getKind() == InitializedEntity::EK_Member &&
6644 isa<CXXConstructorDecl>(S.CurContext)) {
6645 // This is implicit default-initialization of a const member in
6646 // a constructor. Complain that it needs to be explicitly
6648 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext);
6649 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor)
6650 << (Constructor->getInheritedConstructor() ? 2 :
6651 Constructor->isImplicit() ? 1 : 0)
6652 << S.Context.getTypeDeclType(Constructor->getParent())
6654 << Entity.getName();
6655 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl)
6656 << Entity.getName();
6658 S.Diag(Kind.getLocation(), diag::err_default_init_const)
6659 << DestType << (bool)DestType->getAs<RecordType>();
6664 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType,
6665 diag::err_init_incomplete_type);
6668 case FK_ListInitializationFailed: {
6669 // Run the init list checker again to emit diagnostics.
6670 InitListExpr *InitList = cast<InitListExpr>(Args[0]);
6671 diagnoseListInit(S, Entity, InitList);
6675 case FK_PlaceholderType: {
6676 // FIXME: Already diagnosed!
6680 case FK_ExplicitConstructor: {
6681 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor)
6682 << Args[0]->getSourceRange();
6683 OverloadCandidateSet::iterator Best;
6684 OverloadingResult Ovl
6685 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best);
6687 assert(Ovl == OR_Success && "Inconsistent overload resolution");
6688 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function);
6689 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here);
6694 PrintInitLocationNote(S, Entity);
6698 void InitializationSequence::dump(raw_ostream &OS) const {
6699 switch (SequenceKind) {
6700 case FailedSequence: {
6701 OS << "Failed sequence: ";
6703 case FK_TooManyInitsForReference:
6704 OS << "too many initializers for reference";
6707 case FK_ArrayNeedsInitList:
6708 OS << "array requires initializer list";
6711 case FK_ArrayNeedsInitListOrStringLiteral:
6712 OS << "array requires initializer list or string literal";
6715 case FK_ArrayNeedsInitListOrWideStringLiteral:
6716 OS << "array requires initializer list or wide string literal";
6719 case FK_NarrowStringIntoWideCharArray:
6720 OS << "narrow string into wide char array";
6723 case FK_WideStringIntoCharArray:
6724 OS << "wide string into char array";
6727 case FK_IncompatWideStringIntoWideChar:
6728 OS << "incompatible wide string into wide char array";
6731 case FK_ArrayTypeMismatch:
6732 OS << "array type mismatch";
6735 case FK_NonConstantArrayInit:
6736 OS << "non-constant array initializer";
6739 case FK_AddressOfOverloadFailed:
6740 OS << "address of overloaded function failed";
6743 case FK_ReferenceInitOverloadFailed:
6744 OS << "overload resolution for reference initialization failed";
6747 case FK_NonConstLValueReferenceBindingToTemporary:
6748 OS << "non-const lvalue reference bound to temporary";
6751 case FK_NonConstLValueReferenceBindingToUnrelated:
6752 OS << "non-const lvalue reference bound to unrelated type";
6755 case FK_RValueReferenceBindingToLValue:
6756 OS << "rvalue reference bound to an lvalue";
6759 case FK_ReferenceInitDropsQualifiers:
6760 OS << "reference initialization drops qualifiers";
6763 case FK_ReferenceInitFailed:
6764 OS << "reference initialization failed";
6767 case FK_ConversionFailed:
6768 OS << "conversion failed";
6771 case FK_ConversionFromPropertyFailed:
6772 OS << "conversion from property failed";
6775 case FK_TooManyInitsForScalar:
6776 OS << "too many initializers for scalar";
6779 case FK_ReferenceBindingToInitList:
6780 OS << "referencing binding to initializer list";
6783 case FK_InitListBadDestinationType:
6784 OS << "initializer list for non-aggregate, non-scalar type";
6787 case FK_UserConversionOverloadFailed:
6788 OS << "overloading failed for user-defined conversion";
6791 case FK_ConstructorOverloadFailed:
6792 OS << "constructor overloading failed";
6795 case FK_DefaultInitOfConst:
6796 OS << "default initialization of a const variable";
6800 OS << "initialization of incomplete type";
6803 case FK_ListInitializationFailed:
6804 OS << "list initialization checker failure";
6807 case FK_VariableLengthArrayHasInitializer:
6808 OS << "variable length array has an initializer";
6811 case FK_PlaceholderType:
6812 OS << "initializer expression isn't contextually valid";
6815 case FK_ListConstructorOverloadFailed:
6816 OS << "list constructor overloading failed";
6819 case FK_ExplicitConstructor:
6820 OS << "list copy initialization chose explicit constructor";
6827 case DependentSequence:
6828 OS << "Dependent sequence\n";
6831 case NormalSequence:
6832 OS << "Normal sequence: ";
6836 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) {
6837 if (S != step_begin()) {
6842 case SK_ResolveAddressOfOverloadedFunction:
6843 OS << "resolve address of overloaded function";
6846 case SK_CastDerivedToBaseRValue:
6847 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")";
6850 case SK_CastDerivedToBaseXValue:
6851 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")";
6854 case SK_CastDerivedToBaseLValue:
6855 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")";
6858 case SK_BindReference:
6859 OS << "bind reference to lvalue";
6862 case SK_BindReferenceToTemporary:
6863 OS << "bind reference to a temporary";
6866 case SK_ExtraneousCopyToTemporary:
6867 OS << "extraneous C++03 copy to temporary";
6870 case SK_UserConversion:
6871 OS << "user-defined conversion via " << *S->Function.Function;
6874 case SK_QualificationConversionRValue:
6875 OS << "qualification conversion (rvalue)";
6878 case SK_QualificationConversionXValue:
6879 OS << "qualification conversion (xvalue)";
6882 case SK_QualificationConversionLValue:
6883 OS << "qualification conversion (lvalue)";
6886 case SK_LValueToRValue:
6887 OS << "load (lvalue to rvalue)";
6890 case SK_ConversionSequence:
6891 OS << "implicit conversion sequence (";
6892 S->ICS->dump(); // FIXME: use OS
6896 case SK_ConversionSequenceNoNarrowing:
6897 OS << "implicit conversion sequence with narrowing prohibited (";
6898 S->ICS->dump(); // FIXME: use OS
6902 case SK_ListInitialization:
6903 OS << "list aggregate initialization";
6906 case SK_ListConstructorCall:
6907 OS << "list initialization via constructor";
6910 case SK_UnwrapInitList:
6911 OS << "unwrap reference initializer list";
6914 case SK_RewrapInitList:
6915 OS << "rewrap reference initializer list";
6918 case SK_ConstructorInitialization:
6919 OS << "constructor initialization";
6922 case SK_ZeroInitialization:
6923 OS << "zero initialization";
6926 case SK_CAssignment:
6927 OS << "C assignment";
6931 OS << "string initialization";
6934 case SK_ObjCObjectConversion:
6935 OS << "Objective-C object conversion";
6939 OS << "array initialization";
6942 case SK_ParenthesizedArrayInit:
6943 OS << "parenthesized array initialization";
6946 case SK_PassByIndirectCopyRestore:
6947 OS << "pass by indirect copy and restore";
6950 case SK_PassByIndirectRestore:
6951 OS << "pass by indirect restore";
6954 case SK_ProduceObjCObject:
6955 OS << "Objective-C object retension";
6958 case SK_StdInitializerList:
6959 OS << "std::initializer_list from initializer list";
6962 case SK_OCLSamplerInit:
6963 OS << "OpenCL sampler_t from integer constant";
6966 case SK_OCLZeroEvent:
6967 OS << "OpenCL event_t from zero";
6971 OS << " [" << S->Type.getAsString() << ']';
6977 void InitializationSequence::dump() const {
6981 static void DiagnoseNarrowingInInitList(Sema &S,
6982 const ImplicitConversionSequence &ICS,
6983 QualType PreNarrowingType,
6984 QualType EntityType,
6985 const Expr *PostInit) {
6986 const StandardConversionSequence *SCS = 0;
6987 switch (ICS.getKind()) {
6988 case ImplicitConversionSequence::StandardConversion:
6989 SCS = &ICS.Standard;
6991 case ImplicitConversionSequence::UserDefinedConversion:
6992 SCS = &ICS.UserDefined.After;
6994 case ImplicitConversionSequence::AmbiguousConversion:
6995 case ImplicitConversionSequence::EllipsisConversion:
6996 case ImplicitConversionSequence::BadConversion:
7000 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
7001 APValue ConstantValue;
7002 QualType ConstantType;
7003 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
7005 case NK_Not_Narrowing:
7006 // No narrowing occurred.
7009 case NK_Type_Narrowing:
7010 // This was a floating-to-integer conversion, which is always considered a
7011 // narrowing conversion even if the value is a constant and can be
7012 // represented exactly as an integer.
7013 S.Diag(PostInit->getLocStart(),
7014 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7015 ? diag::warn_init_list_type_narrowing
7016 : diag::ext_init_list_type_narrowing)
7017 << PostInit->getSourceRange()
7018 << PreNarrowingType.getLocalUnqualifiedType()
7019 << EntityType.getLocalUnqualifiedType();
7022 case NK_Constant_Narrowing:
7023 // A constant value was narrowed.
7024 S.Diag(PostInit->getLocStart(),
7025 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7026 ? diag::warn_init_list_constant_narrowing
7027 : diag::ext_init_list_constant_narrowing)
7028 << PostInit->getSourceRange()
7029 << ConstantValue.getAsString(S.getASTContext(), ConstantType)
7030 << EntityType.getLocalUnqualifiedType();
7033 case NK_Variable_Narrowing:
7034 // A variable's value may have been narrowed.
7035 S.Diag(PostInit->getLocStart(),
7036 (S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11)
7037 ? diag::warn_init_list_variable_narrowing
7038 : diag::ext_init_list_variable_narrowing)
7039 << PostInit->getSourceRange()
7040 << PreNarrowingType.getLocalUnqualifiedType()
7041 << EntityType.getLocalUnqualifiedType();
7045 SmallString<128> StaticCast;
7046 llvm::raw_svector_ostream OS(StaticCast);
7047 OS << "static_cast<";
7048 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) {
7049 // It's important to use the typedef's name if there is one so that the
7050 // fixit doesn't break code using types like int64_t.
7052 // FIXME: This will break if the typedef requires qualification. But
7053 // getQualifiedNameAsString() includes non-machine-parsable components.
7054 OS << *TT->getDecl();
7055 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>())
7056 OS << BT->getName(S.getLangOpts());
7058 // Oops, we didn't find the actual type of the variable. Don't emit a fixit
7059 // with a broken cast.
7063 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override)
7064 << PostInit->getSourceRange()
7065 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str())
7066 << FixItHint::CreateInsertion(
7067 S.getPreprocessor().getLocForEndOfToken(PostInit->getLocEnd()), ")");
7070 //===----------------------------------------------------------------------===//
7071 // Initialization helper functions
7072 //===----------------------------------------------------------------------===//
7074 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity,
7076 if (Init.isInvalid())
7079 Expr *InitE = Init.get();
7080 assert(InitE && "No initialization expression");
7082 InitializationKind Kind
7083 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation());
7084 InitializationSequence Seq(*this, Entity, Kind, InitE);
7085 return !Seq.Failed();
7089 Sema::PerformCopyInitialization(const InitializedEntity &Entity,
7090 SourceLocation EqualLoc,
7092 bool TopLevelOfInitList,
7093 bool AllowExplicit) {
7094 if (Init.isInvalid())
7097 Expr *InitE = Init.get();
7098 assert(InitE && "No initialization expression?");
7100 if (EqualLoc.isInvalid())
7101 EqualLoc = InitE->getLocStart();
7103 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(),
7106 InitializationSequence Seq(*this, Entity, Kind, InitE, TopLevelOfInitList);
7109 ExprResult Result = Seq.Perform(*this, Entity, Kind, InitE);