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