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