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