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