1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements semantic analysis for initializers. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Sema/Initialization.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/DeclObjC.h" 17 #include "clang/AST/ExprCXX.h" 18 #include "clang/AST/ExprObjC.h" 19 #include "clang/AST/TypeLoc.h" 20 #include "clang/Lex/Preprocessor.h" 21 #include "clang/Sema/Designator.h" 22 #include "clang/Sema/Lookup.h" 23 #include "clang/Sema/SemaInternal.h" 24 #include "llvm/ADT/APInt.h" 25 #include "llvm/ADT/SmallString.h" 26 #include "llvm/Support/ErrorHandling.h" 27 #include "llvm/Support/raw_ostream.h" 28 #include <map> 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().CPlusPlus11 ? 905 diag::warn_cxx98_compat_empty_scalar_initializer : 906 diag::err_empty_scalar_initializer) 907 << IList->getSourceRange(); 908 hadError = !SemaRef.getLangOpts().CPlusPlus11; 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().CPlusPlus11) { 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 // Assume it was supposed to consume a single initializer. 1320 ++Index; 1321 hadError = true; 1322 return; 1323 } 1324 1325 if (DeclType->isUnionType() && IList->getNumInits() == 0) { 1326 // Value-initialize the first named member of the union. 1327 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1328 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 1329 Field != FieldEnd; ++Field) { 1330 if (Field->getDeclName()) { 1331 if (VerifyOnly) 1332 CheckValueInitializable( 1333 InitializedEntity::InitializeMember(*Field, &Entity)); 1334 else 1335 StructuredList->setInitializedFieldInUnion(*Field); 1336 break; 1337 } 1338 } 1339 return; 1340 } 1341 1342 // If structDecl is a forward declaration, this loop won't do 1343 // anything except look at designated initializers; That's okay, 1344 // because an error should get printed out elsewhere. It might be 1345 // worthwhile to skip over the rest of the initializer, though. 1346 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1347 RecordDecl::field_iterator FieldEnd = RD->field_end(); 1348 bool InitializedSomething = false; 1349 bool CheckForMissingFields = true; 1350 while (Index < IList->getNumInits()) { 1351 Expr *Init = IList->getInit(Index); 1352 1353 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1354 // If we're not the subobject that matches up with the '{' for 1355 // the designator, we shouldn't be handling the 1356 // designator. Return immediately. 1357 if (!SubobjectIsDesignatorContext) 1358 return; 1359 1360 // Handle this designated initializer. Field will be updated to 1361 // the next field that we'll be initializing. 1362 if (CheckDesignatedInitializer(Entity, IList, DIE, 0, 1363 DeclType, &Field, 0, Index, 1364 StructuredList, StructuredIndex, 1365 true, TopLevelObject)) 1366 hadError = true; 1367 1368 InitializedSomething = true; 1369 1370 // Disable check for missing fields when designators are used. 1371 // This matches gcc behaviour. 1372 CheckForMissingFields = false; 1373 continue; 1374 } 1375 1376 if (Field == FieldEnd) { 1377 // We've run out of fields. We're done. 1378 break; 1379 } 1380 1381 // We've already initialized a member of a union. We're done. 1382 if (InitializedSomething && DeclType->isUnionType()) 1383 break; 1384 1385 // If we've hit the flexible array member at the end, we're done. 1386 if (Field->getType()->isIncompleteArrayType()) 1387 break; 1388 1389 if (Field->isUnnamedBitfield()) { 1390 // Don't initialize unnamed bitfields, e.g. "int : 20;" 1391 ++Field; 1392 continue; 1393 } 1394 1395 // Make sure we can use this declaration. 1396 bool InvalidUse; 1397 if (VerifyOnly) 1398 InvalidUse = !SemaRef.CanUseDecl(*Field); 1399 else 1400 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, 1401 IList->getInit(Index)->getLocStart()); 1402 if (InvalidUse) { 1403 ++Index; 1404 ++Field; 1405 hadError = true; 1406 continue; 1407 } 1408 1409 InitializedEntity MemberEntity = 1410 InitializedEntity::InitializeMember(*Field, &Entity); 1411 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1412 StructuredList, StructuredIndex); 1413 InitializedSomething = true; 1414 1415 if (DeclType->isUnionType() && !VerifyOnly) { 1416 // Initialize the first field within the union. 1417 StructuredList->setInitializedFieldInUnion(*Field); 1418 } 1419 1420 ++Field; 1421 } 1422 1423 // Emit warnings for missing struct field initializers. 1424 if (!VerifyOnly && InitializedSomething && CheckForMissingFields && 1425 Field != FieldEnd && !Field->getType()->isIncompleteArrayType() && 1426 !DeclType->isUnionType()) { 1427 // It is possible we have one or more unnamed bitfields remaining. 1428 // Find first (if any) named field and emit warning. 1429 for (RecordDecl::field_iterator it = Field, end = RD->field_end(); 1430 it != end; ++it) { 1431 if (!it->isUnnamedBitfield()) { 1432 SemaRef.Diag(IList->getSourceRange().getEnd(), 1433 diag::warn_missing_field_initializers) << it->getName(); 1434 break; 1435 } 1436 } 1437 } 1438 1439 // Check that any remaining fields can be value-initialized. 1440 if (VerifyOnly && Field != FieldEnd && !DeclType->isUnionType() && 1441 !Field->getType()->isIncompleteArrayType()) { 1442 // FIXME: Should check for holes left by designated initializers too. 1443 for (; Field != FieldEnd && !hadError; ++Field) { 1444 if (!Field->isUnnamedBitfield()) 1445 CheckValueInitializable( 1446 InitializedEntity::InitializeMember(*Field, &Entity)); 1447 } 1448 } 1449 1450 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() || 1451 Index >= IList->getNumInits()) 1452 return; 1453 1454 if (CheckFlexibleArrayInit(Entity, IList->getInit(Index), *Field, 1455 TopLevelObject)) { 1456 hadError = true; 1457 ++Index; 1458 return; 1459 } 1460 1461 InitializedEntity MemberEntity = 1462 InitializedEntity::InitializeMember(*Field, &Entity); 1463 1464 if (isa<InitListExpr>(IList->getInit(Index))) 1465 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1466 StructuredList, StructuredIndex); 1467 else 1468 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index, 1469 StructuredList, StructuredIndex); 1470 } 1471 1472 /// \brief Expand a field designator that refers to a member of an 1473 /// anonymous struct or union into a series of field designators that 1474 /// refers to the field within the appropriate subobject. 1475 /// 1476 static void ExpandAnonymousFieldDesignator(Sema &SemaRef, 1477 DesignatedInitExpr *DIE, 1478 unsigned DesigIdx, 1479 IndirectFieldDecl *IndirectField) { 1480 typedef DesignatedInitExpr::Designator Designator; 1481 1482 // Build the replacement designators. 1483 SmallVector<Designator, 4> Replacements; 1484 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(), 1485 PE = IndirectField->chain_end(); PI != PE; ++PI) { 1486 if (PI + 1 == PE) 1487 Replacements.push_back(Designator((IdentifierInfo *)0, 1488 DIE->getDesignator(DesigIdx)->getDotLoc(), 1489 DIE->getDesignator(DesigIdx)->getFieldLoc())); 1490 else 1491 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(), 1492 SourceLocation())); 1493 assert(isa<FieldDecl>(*PI)); 1494 Replacements.back().setField(cast<FieldDecl>(*PI)); 1495 } 1496 1497 // Expand the current designator into the set of replacement 1498 // designators, so we have a full subobject path down to where the 1499 // member of the anonymous struct/union is actually stored. 1500 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0], 1501 &Replacements[0] + Replacements.size()); 1502 } 1503 1504 /// \brief Given an implicit anonymous field, search the IndirectField that 1505 /// corresponds to FieldName. 1506 static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField, 1507 IdentifierInfo *FieldName) { 1508 if (!FieldName) 1509 return 0; 1510 1511 assert(AnonField->isAnonymousStructOrUnion()); 1512 Decl *NextDecl = AnonField->getNextDeclInContext(); 1513 while (IndirectFieldDecl *IF = 1514 dyn_cast_or_null<IndirectFieldDecl>(NextDecl)) { 1515 if (FieldName == IF->getAnonField()->getIdentifier()) 1516 return IF; 1517 NextDecl = NextDecl->getNextDeclInContext(); 1518 } 1519 return 0; 1520 } 1521 1522 static DesignatedInitExpr *CloneDesignatedInitExpr(Sema &SemaRef, 1523 DesignatedInitExpr *DIE) { 1524 unsigned NumIndexExprs = DIE->getNumSubExprs() - 1; 1525 SmallVector<Expr*, 4> IndexExprs(NumIndexExprs); 1526 for (unsigned I = 0; I < NumIndexExprs; ++I) 1527 IndexExprs[I] = DIE->getSubExpr(I + 1); 1528 return DesignatedInitExpr::Create(SemaRef.Context, DIE->designators_begin(), 1529 DIE->size(), IndexExprs, 1530 DIE->getEqualOrColonLoc(), 1531 DIE->usesGNUSyntax(), DIE->getInit()); 1532 } 1533 1534 namespace { 1535 1536 // Callback to only accept typo corrections that are for field members of 1537 // the given struct or union. 1538 class FieldInitializerValidatorCCC : public CorrectionCandidateCallback { 1539 public: 1540 explicit FieldInitializerValidatorCCC(RecordDecl *RD) 1541 : Record(RD) {} 1542 1543 virtual bool ValidateCandidate(const TypoCorrection &candidate) { 1544 FieldDecl *FD = candidate.getCorrectionDeclAs<FieldDecl>(); 1545 return FD && FD->getDeclContext()->getRedeclContext()->Equals(Record); 1546 } 1547 1548 private: 1549 RecordDecl *Record; 1550 }; 1551 1552 } 1553 1554 /// @brief Check the well-formedness of a C99 designated initializer. 1555 /// 1556 /// Determines whether the designated initializer @p DIE, which 1557 /// resides at the given @p Index within the initializer list @p 1558 /// IList, is well-formed for a current object of type @p DeclType 1559 /// (C99 6.7.8). The actual subobject that this designator refers to 1560 /// within the current subobject is returned in either 1561 /// @p NextField or @p NextElementIndex (whichever is appropriate). 1562 /// 1563 /// @param IList The initializer list in which this designated 1564 /// initializer occurs. 1565 /// 1566 /// @param DIE The designated initializer expression. 1567 /// 1568 /// @param DesigIdx The index of the current designator. 1569 /// 1570 /// @param CurrentObjectType The type of the "current object" (C99 6.7.8p17), 1571 /// into which the designation in @p DIE should refer. 1572 /// 1573 /// @param NextField If non-NULL and the first designator in @p DIE is 1574 /// a field, this will be set to the field declaration corresponding 1575 /// to the field named by the designator. 1576 /// 1577 /// @param NextElementIndex If non-NULL and the first designator in @p 1578 /// DIE is an array designator or GNU array-range designator, this 1579 /// will be set to the last index initialized by this designator. 1580 /// 1581 /// @param Index Index into @p IList where the designated initializer 1582 /// @p DIE occurs. 1583 /// 1584 /// @param StructuredList The initializer list expression that 1585 /// describes all of the subobject initializers in the order they'll 1586 /// actually be initialized. 1587 /// 1588 /// @returns true if there was an error, false otherwise. 1589 bool 1590 InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, 1591 InitListExpr *IList, 1592 DesignatedInitExpr *DIE, 1593 unsigned DesigIdx, 1594 QualType &CurrentObjectType, 1595 RecordDecl::field_iterator *NextField, 1596 llvm::APSInt *NextElementIndex, 1597 unsigned &Index, 1598 InitListExpr *StructuredList, 1599 unsigned &StructuredIndex, 1600 bool FinishSubobjectInit, 1601 bool TopLevelObject) { 1602 if (DesigIdx == DIE->size()) { 1603 // Check the actual initialization for the designated object type. 1604 bool prevHadError = hadError; 1605 1606 // Temporarily remove the designator expression from the 1607 // initializer list that the child calls see, so that we don't try 1608 // to re-process the designator. 1609 unsigned OldIndex = Index; 1610 IList->setInit(OldIndex, DIE->getInit()); 1611 1612 CheckSubElementType(Entity, IList, CurrentObjectType, Index, 1613 StructuredList, StructuredIndex); 1614 1615 // Restore the designated initializer expression in the syntactic 1616 // form of the initializer list. 1617 if (IList->getInit(OldIndex) != DIE->getInit()) 1618 DIE->setInit(IList->getInit(OldIndex)); 1619 IList->setInit(OldIndex, DIE); 1620 1621 return hadError && !prevHadError; 1622 } 1623 1624 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx); 1625 bool IsFirstDesignator = (DesigIdx == 0); 1626 if (!VerifyOnly) { 1627 assert((IsFirstDesignator || StructuredList) && 1628 "Need a non-designated initializer list to start from"); 1629 1630 // Determine the structural initializer list that corresponds to the 1631 // current subobject. 1632 StructuredList = IsFirstDesignator? SyntacticToSemantic.lookup(IList) 1633 : getStructuredSubobjectInit(IList, Index, CurrentObjectType, 1634 StructuredList, StructuredIndex, 1635 SourceRange(D->getLocStart(), 1636 DIE->getLocEnd())); 1637 assert(StructuredList && "Expected a structured initializer list"); 1638 } 1639 1640 if (D->isFieldDesignator()) { 1641 // C99 6.7.8p7: 1642 // 1643 // If a designator has the form 1644 // 1645 // . identifier 1646 // 1647 // then the current object (defined below) shall have 1648 // structure or union type and the identifier shall be the 1649 // name of a member of that type. 1650 const RecordType *RT = CurrentObjectType->getAs<RecordType>(); 1651 if (!RT) { 1652 SourceLocation Loc = D->getDotLoc(); 1653 if (Loc.isInvalid()) 1654 Loc = D->getFieldLoc(); 1655 if (!VerifyOnly) 1656 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr) 1657 << SemaRef.getLangOpts().CPlusPlus << CurrentObjectType; 1658 ++Index; 1659 return true; 1660 } 1661 1662 // Note: we perform a linear search of the fields here, despite 1663 // the fact that we have a faster lookup method, because we always 1664 // need to compute the field's index. 1665 FieldDecl *KnownField = D->getField(); 1666 IdentifierInfo *FieldName = D->getFieldName(); 1667 unsigned FieldIndex = 0; 1668 RecordDecl::field_iterator 1669 Field = RT->getDecl()->field_begin(), 1670 FieldEnd = RT->getDecl()->field_end(); 1671 for (; Field != FieldEnd; ++Field) { 1672 if (Field->isUnnamedBitfield()) 1673 continue; 1674 1675 // If we find a field representing an anonymous field, look in the 1676 // IndirectFieldDecl that follow for the designated initializer. 1677 if (!KnownField && Field->isAnonymousStructOrUnion()) { 1678 if (IndirectFieldDecl *IF = 1679 FindIndirectFieldDesignator(*Field, FieldName)) { 1680 // In verify mode, don't modify the original. 1681 if (VerifyOnly) 1682 DIE = CloneDesignatedInitExpr(SemaRef, DIE); 1683 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF); 1684 D = DIE->getDesignator(DesigIdx); 1685 break; 1686 } 1687 } 1688 if (KnownField && KnownField == *Field) 1689 break; 1690 if (FieldName && FieldName == Field->getIdentifier()) 1691 break; 1692 1693 ++FieldIndex; 1694 } 1695 1696 if (Field == FieldEnd) { 1697 if (VerifyOnly) { 1698 ++Index; 1699 return true; // No typo correction when just trying this out. 1700 } 1701 1702 // There was no normal field in the struct with the designated 1703 // name. Perform another lookup for this name, which may find 1704 // something that we can't designate (e.g., a member function), 1705 // may find nothing, or may find a member of an anonymous 1706 // struct/union. 1707 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName); 1708 FieldDecl *ReplacementField = 0; 1709 if (Lookup.empty()) { 1710 // Name lookup didn't find anything. Determine whether this 1711 // was a typo for another field name. 1712 FieldInitializerValidatorCCC Validator(RT->getDecl()); 1713 TypoCorrection Corrected = SemaRef.CorrectTypo( 1714 DeclarationNameInfo(FieldName, D->getFieldLoc()), 1715 Sema::LookupMemberName, /*Scope=*/0, /*SS=*/0, Validator, 1716 RT->getDecl()); 1717 if (Corrected) { 1718 std::string CorrectedStr( 1719 Corrected.getAsString(SemaRef.getLangOpts())); 1720 std::string CorrectedQuotedStr( 1721 Corrected.getQuoted(SemaRef.getLangOpts())); 1722 ReplacementField = Corrected.getCorrectionDeclAs<FieldDecl>(); 1723 SemaRef.Diag(D->getFieldLoc(), 1724 diag::err_field_designator_unknown_suggest) 1725 << FieldName << CurrentObjectType << CorrectedQuotedStr 1726 << FixItHint::CreateReplacement(D->getFieldLoc(), CorrectedStr); 1727 SemaRef.Diag(ReplacementField->getLocation(), 1728 diag::note_previous_decl) << CorrectedQuotedStr; 1729 hadError = true; 1730 } else { 1731 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown) 1732 << FieldName << CurrentObjectType; 1733 ++Index; 1734 return true; 1735 } 1736 } 1737 1738 if (!ReplacementField) { 1739 // Name lookup found something, but it wasn't a field. 1740 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield) 1741 << FieldName; 1742 SemaRef.Diag(Lookup.front()->getLocation(), 1743 diag::note_field_designator_found); 1744 ++Index; 1745 return true; 1746 } 1747 1748 if (!KnownField) { 1749 // The replacement field comes from typo correction; find it 1750 // in the list of fields. 1751 FieldIndex = 0; 1752 Field = RT->getDecl()->field_begin(); 1753 for (; Field != FieldEnd; ++Field) { 1754 if (Field->isUnnamedBitfield()) 1755 continue; 1756 1757 if (ReplacementField == *Field || 1758 Field->getIdentifier() == ReplacementField->getIdentifier()) 1759 break; 1760 1761 ++FieldIndex; 1762 } 1763 } 1764 } 1765 1766 // All of the fields of a union are located at the same place in 1767 // the initializer list. 1768 if (RT->getDecl()->isUnion()) { 1769 FieldIndex = 0; 1770 if (!VerifyOnly) 1771 StructuredList->setInitializedFieldInUnion(*Field); 1772 } 1773 1774 // Make sure we can use this declaration. 1775 bool InvalidUse; 1776 if (VerifyOnly) 1777 InvalidUse = !SemaRef.CanUseDecl(*Field); 1778 else 1779 InvalidUse = SemaRef.DiagnoseUseOfDecl(*Field, D->getFieldLoc()); 1780 if (InvalidUse) { 1781 ++Index; 1782 return true; 1783 } 1784 1785 if (!VerifyOnly) { 1786 // Update the designator with the field declaration. 1787 D->setField(*Field); 1788 1789 // Make sure that our non-designated initializer list has space 1790 // for a subobject corresponding to this field. 1791 if (FieldIndex >= StructuredList->getNumInits()) 1792 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1); 1793 } 1794 1795 // This designator names a flexible array member. 1796 if (Field->getType()->isIncompleteArrayType()) { 1797 bool Invalid = false; 1798 if ((DesigIdx + 1) != DIE->size()) { 1799 // We can't designate an object within the flexible array 1800 // member (because GCC doesn't allow it). 1801 if (!VerifyOnly) { 1802 DesignatedInitExpr::Designator *NextD 1803 = DIE->getDesignator(DesigIdx + 1); 1804 SemaRef.Diag(NextD->getLocStart(), 1805 diag::err_designator_into_flexible_array_member) 1806 << SourceRange(NextD->getLocStart(), 1807 DIE->getLocEnd()); 1808 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1809 << *Field; 1810 } 1811 Invalid = true; 1812 } 1813 1814 if (!hadError && !isa<InitListExpr>(DIE->getInit()) && 1815 !isa<StringLiteral>(DIE->getInit())) { 1816 // The initializer is not an initializer list. 1817 if (!VerifyOnly) { 1818 SemaRef.Diag(DIE->getInit()->getLocStart(), 1819 diag::err_flexible_array_init_needs_braces) 1820 << DIE->getInit()->getSourceRange(); 1821 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1822 << *Field; 1823 } 1824 Invalid = true; 1825 } 1826 1827 // Check GNU flexible array initializer. 1828 if (!Invalid && CheckFlexibleArrayInit(Entity, DIE->getInit(), *Field, 1829 TopLevelObject)) 1830 Invalid = true; 1831 1832 if (Invalid) { 1833 ++Index; 1834 return true; 1835 } 1836 1837 // Initialize the array. 1838 bool prevHadError = hadError; 1839 unsigned newStructuredIndex = FieldIndex; 1840 unsigned OldIndex = Index; 1841 IList->setInit(Index, DIE->getInit()); 1842 1843 InitializedEntity MemberEntity = 1844 InitializedEntity::InitializeMember(*Field, &Entity); 1845 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1846 StructuredList, newStructuredIndex); 1847 1848 IList->setInit(OldIndex, DIE); 1849 if (hadError && !prevHadError) { 1850 ++Field; 1851 ++FieldIndex; 1852 if (NextField) 1853 *NextField = Field; 1854 StructuredIndex = FieldIndex; 1855 return true; 1856 } 1857 } else { 1858 // Recurse to check later designated subobjects. 1859 QualType FieldType = Field->getType(); 1860 unsigned newStructuredIndex = FieldIndex; 1861 1862 InitializedEntity MemberEntity = 1863 InitializedEntity::InitializeMember(*Field, &Entity); 1864 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1, 1865 FieldType, 0, 0, Index, 1866 StructuredList, newStructuredIndex, 1867 true, false)) 1868 return true; 1869 } 1870 1871 // Find the position of the next field to be initialized in this 1872 // subobject. 1873 ++Field; 1874 ++FieldIndex; 1875 1876 // If this the first designator, our caller will continue checking 1877 // the rest of this struct/class/union subobject. 1878 if (IsFirstDesignator) { 1879 if (NextField) 1880 *NextField = Field; 1881 StructuredIndex = FieldIndex; 1882 return false; 1883 } 1884 1885 if (!FinishSubobjectInit) 1886 return false; 1887 1888 // We've already initialized something in the union; we're done. 1889 if (RT->getDecl()->isUnion()) 1890 return hadError; 1891 1892 // Check the remaining fields within this class/struct/union subobject. 1893 bool prevHadError = hadError; 1894 1895 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index, 1896 StructuredList, FieldIndex); 1897 return hadError && !prevHadError; 1898 } 1899 1900 // C99 6.7.8p6: 1901 // 1902 // If a designator has the form 1903 // 1904 // [ constant-expression ] 1905 // 1906 // then the current object (defined below) shall have array 1907 // type and the expression shall be an integer constant 1908 // expression. If the array is of unknown size, any 1909 // nonnegative value is valid. 1910 // 1911 // Additionally, cope with the GNU extension that permits 1912 // designators of the form 1913 // 1914 // [ constant-expression ... constant-expression ] 1915 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType); 1916 if (!AT) { 1917 if (!VerifyOnly) 1918 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) 1919 << CurrentObjectType; 1920 ++Index; 1921 return true; 1922 } 1923 1924 Expr *IndexExpr = 0; 1925 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex; 1926 if (D->isArrayDesignator()) { 1927 IndexExpr = DIE->getArrayIndex(*D); 1928 DesignatedStartIndex = IndexExpr->EvaluateKnownConstInt(SemaRef.Context); 1929 DesignatedEndIndex = DesignatedStartIndex; 1930 } else { 1931 assert(D->isArrayRangeDesignator() && "Need array-range designator"); 1932 1933 DesignatedStartIndex = 1934 DIE->getArrayRangeStart(*D)->EvaluateKnownConstInt(SemaRef.Context); 1935 DesignatedEndIndex = 1936 DIE->getArrayRangeEnd(*D)->EvaluateKnownConstInt(SemaRef.Context); 1937 IndexExpr = DIE->getArrayRangeEnd(*D); 1938 1939 // Codegen can't handle evaluating array range designators that have side 1940 // effects, because we replicate the AST value for each initialized element. 1941 // As such, set the sawArrayRangeDesignator() bit if we initialize multiple 1942 // elements with something that has a side effect, so codegen can emit an 1943 // "error unsupported" error instead of miscompiling the app. 1944 if (DesignatedStartIndex.getZExtValue()!=DesignatedEndIndex.getZExtValue()&& 1945 DIE->getInit()->HasSideEffects(SemaRef.Context) && !VerifyOnly) 1946 FullyStructuredList->sawArrayRangeDesignator(); 1947 } 1948 1949 if (isa<ConstantArrayType>(AT)) { 1950 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false); 1951 DesignatedStartIndex 1952 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth()); 1953 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned()); 1954 DesignatedEndIndex 1955 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth()); 1956 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned()); 1957 if (DesignatedEndIndex >= MaxElements) { 1958 if (!VerifyOnly) 1959 SemaRef.Diag(IndexExpr->getLocStart(), 1960 diag::err_array_designator_too_large) 1961 << DesignatedEndIndex.toString(10) << MaxElements.toString(10) 1962 << IndexExpr->getSourceRange(); 1963 ++Index; 1964 return true; 1965 } 1966 } else { 1967 // Make sure the bit-widths and signedness match. 1968 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth()) 1969 DesignatedEndIndex 1970 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth()); 1971 else if (DesignatedStartIndex.getBitWidth() < 1972 DesignatedEndIndex.getBitWidth()) 1973 DesignatedStartIndex 1974 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth()); 1975 DesignatedStartIndex.setIsUnsigned(true); 1976 DesignatedEndIndex.setIsUnsigned(true); 1977 } 1978 1979 // Make sure that our non-designated initializer list has space 1980 // for a subobject corresponding to this array element. 1981 if (!VerifyOnly && 1982 DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits()) 1983 StructuredList->resizeInits(SemaRef.Context, 1984 DesignatedEndIndex.getZExtValue() + 1); 1985 1986 // Repeatedly perform subobject initializations in the range 1987 // [DesignatedStartIndex, DesignatedEndIndex]. 1988 1989 // Move to the next designator 1990 unsigned ElementIndex = DesignatedStartIndex.getZExtValue(); 1991 unsigned OldIndex = Index; 1992 1993 InitializedEntity ElementEntity = 1994 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 1995 1996 while (DesignatedStartIndex <= DesignatedEndIndex) { 1997 // Recurse to check later designated subobjects. 1998 QualType ElementType = AT->getElementType(); 1999 Index = OldIndex; 2000 2001 ElementEntity.setElementIndex(ElementIndex); 2002 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1, 2003 ElementType, 0, 0, Index, 2004 StructuredList, ElementIndex, 2005 (DesignatedStartIndex == DesignatedEndIndex), 2006 false)) 2007 return true; 2008 2009 // Move to the next index in the array that we'll be initializing. 2010 ++DesignatedStartIndex; 2011 ElementIndex = DesignatedStartIndex.getZExtValue(); 2012 } 2013 2014 // If this the first designator, our caller will continue checking 2015 // the rest of this array subobject. 2016 if (IsFirstDesignator) { 2017 if (NextElementIndex) 2018 *NextElementIndex = DesignatedStartIndex; 2019 StructuredIndex = ElementIndex; 2020 return false; 2021 } 2022 2023 if (!FinishSubobjectInit) 2024 return false; 2025 2026 // Check the remaining elements within this array subobject. 2027 bool prevHadError = hadError; 2028 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex, 2029 /*SubobjectIsDesignatorContext=*/false, Index, 2030 StructuredList, ElementIndex); 2031 return hadError && !prevHadError; 2032 } 2033 2034 // Get the structured initializer list for a subobject of type 2035 // @p CurrentObjectType. 2036 InitListExpr * 2037 InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 2038 QualType CurrentObjectType, 2039 InitListExpr *StructuredList, 2040 unsigned StructuredIndex, 2041 SourceRange InitRange) { 2042 if (VerifyOnly) 2043 return 0; // No structured list in verification-only mode. 2044 Expr *ExistingInit = 0; 2045 if (!StructuredList) 2046 ExistingInit = SyntacticToSemantic.lookup(IList); 2047 else if (StructuredIndex < StructuredList->getNumInits()) 2048 ExistingInit = StructuredList->getInit(StructuredIndex); 2049 2050 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) 2051 return Result; 2052 2053 if (ExistingInit) { 2054 // We are creating an initializer list that initializes the 2055 // subobjects of the current object, but there was already an 2056 // initialization that completely initialized the current 2057 // subobject, e.g., by a compound literal: 2058 // 2059 // struct X { int a, b; }; 2060 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 2061 // 2062 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 2063 // designated initializer re-initializes the whole 2064 // subobject [0], overwriting previous initializers. 2065 SemaRef.Diag(InitRange.getBegin(), 2066 diag::warn_subobject_initializer_overrides) 2067 << InitRange; 2068 SemaRef.Diag(ExistingInit->getLocStart(), 2069 diag::note_previous_initializer) 2070 << /*FIXME:has side effects=*/0 2071 << ExistingInit->getSourceRange(); 2072 } 2073 2074 InitListExpr *Result 2075 = new (SemaRef.Context) InitListExpr(SemaRef.Context, 2076 InitRange.getBegin(), MultiExprArg(), 2077 InitRange.getEnd()); 2078 2079 QualType ResultType = CurrentObjectType; 2080 if (!ResultType->isArrayType()) 2081 ResultType = ResultType.getNonLValueExprType(SemaRef.Context); 2082 Result->setType(ResultType); 2083 2084 // Pre-allocate storage for the structured initializer list. 2085 unsigned NumElements = 0; 2086 unsigned NumInits = 0; 2087 bool GotNumInits = false; 2088 if (!StructuredList) { 2089 NumInits = IList->getNumInits(); 2090 GotNumInits = true; 2091 } else if (Index < IList->getNumInits()) { 2092 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) { 2093 NumInits = SubList->getNumInits(); 2094 GotNumInits = true; 2095 } 2096 } 2097 2098 if (const ArrayType *AType 2099 = SemaRef.Context.getAsArrayType(CurrentObjectType)) { 2100 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) { 2101 NumElements = CAType->getSize().getZExtValue(); 2102 // Simple heuristic so that we don't allocate a very large 2103 // initializer with many empty entries at the end. 2104 if (GotNumInits && NumElements > NumInits) 2105 NumElements = 0; 2106 } 2107 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>()) 2108 NumElements = VType->getNumElements(); 2109 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) { 2110 RecordDecl *RDecl = RType->getDecl(); 2111 if (RDecl->isUnion()) 2112 NumElements = 1; 2113 else 2114 NumElements = std::distance(RDecl->field_begin(), 2115 RDecl->field_end()); 2116 } 2117 2118 Result->reserveInits(SemaRef.Context, NumElements); 2119 2120 // Link this new initializer list into the structured initializer 2121 // lists. 2122 if (StructuredList) 2123 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result); 2124 else { 2125 Result->setSyntacticForm(IList); 2126 SyntacticToSemantic[IList] = Result; 2127 } 2128 2129 return Result; 2130 } 2131 2132 /// Update the initializer at index @p StructuredIndex within the 2133 /// structured initializer list to the value @p expr. 2134 void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, 2135 unsigned &StructuredIndex, 2136 Expr *expr) { 2137 // No structured initializer list to update 2138 if (!StructuredList) 2139 return; 2140 2141 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context, 2142 StructuredIndex, expr)) { 2143 // This initializer overwrites a previous initializer. Warn. 2144 SemaRef.Diag(expr->getLocStart(), 2145 diag::warn_initializer_overrides) 2146 << expr->getSourceRange(); 2147 SemaRef.Diag(PrevInit->getLocStart(), 2148 diag::note_previous_initializer) 2149 << /*FIXME:has side effects=*/0 2150 << PrevInit->getSourceRange(); 2151 } 2152 2153 ++StructuredIndex; 2154 } 2155 2156 /// Check that the given Index expression is a valid array designator 2157 /// value. This is essentially just a wrapper around 2158 /// VerifyIntegerConstantExpression that also checks for negative values 2159 /// and produces a reasonable diagnostic if there is a 2160 /// failure. Returns the index expression, possibly with an implicit cast 2161 /// added, on success. If everything went okay, Value will receive the 2162 /// value of the constant expression. 2163 static ExprResult 2164 CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) { 2165 SourceLocation Loc = Index->getLocStart(); 2166 2167 // Make sure this is an integer constant expression. 2168 ExprResult Result = S.VerifyIntegerConstantExpression(Index, &Value); 2169 if (Result.isInvalid()) 2170 return Result; 2171 2172 if (Value.isSigned() && Value.isNegative()) 2173 return S.Diag(Loc, diag::err_array_designator_negative) 2174 << Value.toString(10) << Index->getSourceRange(); 2175 2176 Value.setIsUnsigned(true); 2177 return Result; 2178 } 2179 2180 ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, 2181 SourceLocation Loc, 2182 bool GNUSyntax, 2183 ExprResult Init) { 2184 typedef DesignatedInitExpr::Designator ASTDesignator; 2185 2186 bool Invalid = false; 2187 SmallVector<ASTDesignator, 32> Designators; 2188 SmallVector<Expr *, 32> InitExpressions; 2189 2190 // Build designators and check array designator expressions. 2191 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { 2192 const Designator &D = Desig.getDesignator(Idx); 2193 switch (D.getKind()) { 2194 case Designator::FieldDesignator: 2195 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), 2196 D.getFieldLoc())); 2197 break; 2198 2199 case Designator::ArrayDesignator: { 2200 Expr *Index = static_cast<Expr *>(D.getArrayIndex()); 2201 llvm::APSInt IndexValue; 2202 if (!Index->isTypeDependent() && !Index->isValueDependent()) 2203 Index = CheckArrayDesignatorExpr(*this, Index, IndexValue).take(); 2204 if (!Index) 2205 Invalid = true; 2206 else { 2207 Designators.push_back(ASTDesignator(InitExpressions.size(), 2208 D.getLBracketLoc(), 2209 D.getRBracketLoc())); 2210 InitExpressions.push_back(Index); 2211 } 2212 break; 2213 } 2214 2215 case Designator::ArrayRangeDesignator: { 2216 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); 2217 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); 2218 llvm::APSInt StartValue; 2219 llvm::APSInt EndValue; 2220 bool StartDependent = StartIndex->isTypeDependent() || 2221 StartIndex->isValueDependent(); 2222 bool EndDependent = EndIndex->isTypeDependent() || 2223 EndIndex->isValueDependent(); 2224 if (!StartDependent) 2225 StartIndex = 2226 CheckArrayDesignatorExpr(*this, StartIndex, StartValue).take(); 2227 if (!EndDependent) 2228 EndIndex = CheckArrayDesignatorExpr(*this, EndIndex, EndValue).take(); 2229 2230 if (!StartIndex || !EndIndex) 2231 Invalid = true; 2232 else { 2233 // Make sure we're comparing values with the same bit width. 2234 if (StartDependent || EndDependent) { 2235 // Nothing to compute. 2236 } else if (StartValue.getBitWidth() > EndValue.getBitWidth()) 2237 EndValue = EndValue.extend(StartValue.getBitWidth()); 2238 else if (StartValue.getBitWidth() < EndValue.getBitWidth()) 2239 StartValue = StartValue.extend(EndValue.getBitWidth()); 2240 2241 if (!StartDependent && !EndDependent && EndValue < StartValue) { 2242 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) 2243 << StartValue.toString(10) << EndValue.toString(10) 2244 << StartIndex->getSourceRange() << EndIndex->getSourceRange(); 2245 Invalid = true; 2246 } else { 2247 Designators.push_back(ASTDesignator(InitExpressions.size(), 2248 D.getLBracketLoc(), 2249 D.getEllipsisLoc(), 2250 D.getRBracketLoc())); 2251 InitExpressions.push_back(StartIndex); 2252 InitExpressions.push_back(EndIndex); 2253 } 2254 } 2255 break; 2256 } 2257 } 2258 } 2259 2260 if (Invalid || Init.isInvalid()) 2261 return ExprError(); 2262 2263 // Clear out the expressions within the designation. 2264 Desig.ClearExprs(*this); 2265 2266 DesignatedInitExpr *DIE 2267 = DesignatedInitExpr::Create(Context, 2268 Designators.data(), Designators.size(), 2269 InitExpressions, Loc, GNUSyntax, 2270 Init.takeAs<Expr>()); 2271 2272 if (!getLangOpts().C99) 2273 Diag(DIE->getLocStart(), diag::ext_designated_init) 2274 << DIE->getSourceRange(); 2275 2276 return Owned(DIE); 2277 } 2278 2279 //===----------------------------------------------------------------------===// 2280 // Initialization entity 2281 //===----------------------------------------------------------------------===// 2282 2283 InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index, 2284 const InitializedEntity &Parent) 2285 : Parent(&Parent), Index(Index) 2286 { 2287 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) { 2288 Kind = EK_ArrayElement; 2289 Type = AT->getElementType(); 2290 } else if (const VectorType *VT = Parent.getType()->getAs<VectorType>()) { 2291 Kind = EK_VectorElement; 2292 Type = VT->getElementType(); 2293 } else { 2294 const ComplexType *CT = Parent.getType()->getAs<ComplexType>(); 2295 assert(CT && "Unexpected type"); 2296 Kind = EK_ComplexElement; 2297 Type = CT->getElementType(); 2298 } 2299 } 2300 2301 InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context, 2302 CXXBaseSpecifier *Base, 2303 bool IsInheritedVirtualBase) 2304 { 2305 InitializedEntity Result; 2306 Result.Kind = EK_Base; 2307 Result.Base = reinterpret_cast<uintptr_t>(Base); 2308 if (IsInheritedVirtualBase) 2309 Result.Base |= 0x01; 2310 2311 Result.Type = Base->getType(); 2312 return Result; 2313 } 2314 2315 DeclarationName InitializedEntity::getName() const { 2316 switch (getKind()) { 2317 case EK_Parameter: { 2318 ParmVarDecl *D = reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1); 2319 return (D ? D->getDeclName() : DeclarationName()); 2320 } 2321 2322 case EK_Variable: 2323 case EK_Member: 2324 return VariableOrMember->getDeclName(); 2325 2326 case EK_LambdaCapture: 2327 return Capture.Var->getDeclName(); 2328 2329 case EK_Result: 2330 case EK_Exception: 2331 case EK_New: 2332 case EK_Temporary: 2333 case EK_Base: 2334 case EK_Delegating: 2335 case EK_ArrayElement: 2336 case EK_VectorElement: 2337 case EK_ComplexElement: 2338 case EK_BlockElement: 2339 return DeclarationName(); 2340 } 2341 2342 llvm_unreachable("Invalid EntityKind!"); 2343 } 2344 2345 DeclaratorDecl *InitializedEntity::getDecl() const { 2346 switch (getKind()) { 2347 case EK_Variable: 2348 case EK_Member: 2349 return VariableOrMember; 2350 2351 case EK_Parameter: 2352 return reinterpret_cast<ParmVarDecl*>(Parameter & ~0x1); 2353 2354 case EK_Result: 2355 case EK_Exception: 2356 case EK_New: 2357 case EK_Temporary: 2358 case EK_Base: 2359 case EK_Delegating: 2360 case EK_ArrayElement: 2361 case EK_VectorElement: 2362 case EK_ComplexElement: 2363 case EK_BlockElement: 2364 case EK_LambdaCapture: 2365 return 0; 2366 } 2367 2368 llvm_unreachable("Invalid EntityKind!"); 2369 } 2370 2371 bool InitializedEntity::allowsNRVO() const { 2372 switch (getKind()) { 2373 case EK_Result: 2374 case EK_Exception: 2375 return LocAndNRVO.NRVO; 2376 2377 case EK_Variable: 2378 case EK_Parameter: 2379 case EK_Member: 2380 case EK_New: 2381 case EK_Temporary: 2382 case EK_Base: 2383 case EK_Delegating: 2384 case EK_ArrayElement: 2385 case EK_VectorElement: 2386 case EK_ComplexElement: 2387 case EK_BlockElement: 2388 case EK_LambdaCapture: 2389 break; 2390 } 2391 2392 return false; 2393 } 2394 2395 //===----------------------------------------------------------------------===// 2396 // Initialization sequence 2397 //===----------------------------------------------------------------------===// 2398 2399 void InitializationSequence::Step::Destroy() { 2400 switch (Kind) { 2401 case SK_ResolveAddressOfOverloadedFunction: 2402 case SK_CastDerivedToBaseRValue: 2403 case SK_CastDerivedToBaseXValue: 2404 case SK_CastDerivedToBaseLValue: 2405 case SK_BindReference: 2406 case SK_BindReferenceToTemporary: 2407 case SK_ExtraneousCopyToTemporary: 2408 case SK_UserConversion: 2409 case SK_QualificationConversionRValue: 2410 case SK_QualificationConversionXValue: 2411 case SK_QualificationConversionLValue: 2412 case SK_ListInitialization: 2413 case SK_ListConstructorCall: 2414 case SK_UnwrapInitList: 2415 case SK_RewrapInitList: 2416 case SK_ConstructorInitialization: 2417 case SK_ZeroInitialization: 2418 case SK_CAssignment: 2419 case SK_StringInit: 2420 case SK_ObjCObjectConversion: 2421 case SK_ArrayInit: 2422 case SK_ParenthesizedArrayInit: 2423 case SK_PassByIndirectCopyRestore: 2424 case SK_PassByIndirectRestore: 2425 case SK_ProduceObjCObject: 2426 case SK_StdInitializerList: 2427 case SK_OCLSamplerInit: 2428 case SK_OCLZeroEvent: 2429 break; 2430 2431 case SK_ConversionSequence: 2432 delete ICS; 2433 } 2434 } 2435 2436 bool InitializationSequence::isDirectReferenceBinding() const { 2437 return !Steps.empty() && Steps.back().Kind == SK_BindReference; 2438 } 2439 2440 bool InitializationSequence::isAmbiguous() const { 2441 if (!Failed()) 2442 return false; 2443 2444 switch (getFailureKind()) { 2445 case FK_TooManyInitsForReference: 2446 case FK_ArrayNeedsInitList: 2447 case FK_ArrayNeedsInitListOrStringLiteral: 2448 case FK_AddressOfOverloadFailed: // FIXME: Could do better 2449 case FK_NonConstLValueReferenceBindingToTemporary: 2450 case FK_NonConstLValueReferenceBindingToUnrelated: 2451 case FK_RValueReferenceBindingToLValue: 2452 case FK_ReferenceInitDropsQualifiers: 2453 case FK_ReferenceInitFailed: 2454 case FK_ConversionFailed: 2455 case FK_ConversionFromPropertyFailed: 2456 case FK_TooManyInitsForScalar: 2457 case FK_ReferenceBindingToInitList: 2458 case FK_InitListBadDestinationType: 2459 case FK_DefaultInitOfConst: 2460 case FK_Incomplete: 2461 case FK_ArrayTypeMismatch: 2462 case FK_NonConstantArrayInit: 2463 case FK_ListInitializationFailed: 2464 case FK_VariableLengthArrayHasInitializer: 2465 case FK_PlaceholderType: 2466 case FK_InitListElementCopyFailure: 2467 case FK_ExplicitConstructor: 2468 return false; 2469 2470 case FK_ReferenceInitOverloadFailed: 2471 case FK_UserConversionOverloadFailed: 2472 case FK_ConstructorOverloadFailed: 2473 case FK_ListConstructorOverloadFailed: 2474 return FailedOverloadResult == OR_Ambiguous; 2475 } 2476 2477 llvm_unreachable("Invalid EntityKind!"); 2478 } 2479 2480 bool InitializationSequence::isConstructorInitialization() const { 2481 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization; 2482 } 2483 2484 void 2485 InitializationSequence 2486 ::AddAddressOverloadResolutionStep(FunctionDecl *Function, 2487 DeclAccessPair Found, 2488 bool HadMultipleCandidates) { 2489 Step S; 2490 S.Kind = SK_ResolveAddressOfOverloadedFunction; 2491 S.Type = Function->getType(); 2492 S.Function.HadMultipleCandidates = HadMultipleCandidates; 2493 S.Function.Function = Function; 2494 S.Function.FoundDecl = Found; 2495 Steps.push_back(S); 2496 } 2497 2498 void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType, 2499 ExprValueKind VK) { 2500 Step S; 2501 switch (VK) { 2502 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break; 2503 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break; 2504 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break; 2505 } 2506 S.Type = BaseType; 2507 Steps.push_back(S); 2508 } 2509 2510 void InitializationSequence::AddReferenceBindingStep(QualType T, 2511 bool BindingTemporary) { 2512 Step S; 2513 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference; 2514 S.Type = T; 2515 Steps.push_back(S); 2516 } 2517 2518 void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) { 2519 Step S; 2520 S.Kind = SK_ExtraneousCopyToTemporary; 2521 S.Type = T; 2522 Steps.push_back(S); 2523 } 2524 2525 void 2526 InitializationSequence::AddUserConversionStep(FunctionDecl *Function, 2527 DeclAccessPair FoundDecl, 2528 QualType T, 2529 bool HadMultipleCandidates) { 2530 Step S; 2531 S.Kind = SK_UserConversion; 2532 S.Type = T; 2533 S.Function.HadMultipleCandidates = HadMultipleCandidates; 2534 S.Function.Function = Function; 2535 S.Function.FoundDecl = FoundDecl; 2536 Steps.push_back(S); 2537 } 2538 2539 void InitializationSequence::AddQualificationConversionStep(QualType Ty, 2540 ExprValueKind VK) { 2541 Step S; 2542 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning 2543 switch (VK) { 2544 case VK_RValue: 2545 S.Kind = SK_QualificationConversionRValue; 2546 break; 2547 case VK_XValue: 2548 S.Kind = SK_QualificationConversionXValue; 2549 break; 2550 case VK_LValue: 2551 S.Kind = SK_QualificationConversionLValue; 2552 break; 2553 } 2554 S.Type = Ty; 2555 Steps.push_back(S); 2556 } 2557 2558 void InitializationSequence::AddConversionSequenceStep( 2559 const ImplicitConversionSequence &ICS, 2560 QualType T) { 2561 Step S; 2562 S.Kind = SK_ConversionSequence; 2563 S.Type = T; 2564 S.ICS = new ImplicitConversionSequence(ICS); 2565 Steps.push_back(S); 2566 } 2567 2568 void InitializationSequence::AddListInitializationStep(QualType T) { 2569 Step S; 2570 S.Kind = SK_ListInitialization; 2571 S.Type = T; 2572 Steps.push_back(S); 2573 } 2574 2575 void 2576 InitializationSequence 2577 ::AddConstructorInitializationStep(CXXConstructorDecl *Constructor, 2578 AccessSpecifier Access, 2579 QualType T, 2580 bool HadMultipleCandidates, 2581 bool FromInitList, bool AsInitList) { 2582 Step S; 2583 S.Kind = FromInitList && !AsInitList ? SK_ListConstructorCall 2584 : SK_ConstructorInitialization; 2585 S.Type = T; 2586 S.Function.HadMultipleCandidates = HadMultipleCandidates; 2587 S.Function.Function = Constructor; 2588 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access); 2589 Steps.push_back(S); 2590 } 2591 2592 void InitializationSequence::AddZeroInitializationStep(QualType T) { 2593 Step S; 2594 S.Kind = SK_ZeroInitialization; 2595 S.Type = T; 2596 Steps.push_back(S); 2597 } 2598 2599 void InitializationSequence::AddCAssignmentStep(QualType T) { 2600 Step S; 2601 S.Kind = SK_CAssignment; 2602 S.Type = T; 2603 Steps.push_back(S); 2604 } 2605 2606 void InitializationSequence::AddStringInitStep(QualType T) { 2607 Step S; 2608 S.Kind = SK_StringInit; 2609 S.Type = T; 2610 Steps.push_back(S); 2611 } 2612 2613 void InitializationSequence::AddObjCObjectConversionStep(QualType T) { 2614 Step S; 2615 S.Kind = SK_ObjCObjectConversion; 2616 S.Type = T; 2617 Steps.push_back(S); 2618 } 2619 2620 void InitializationSequence::AddArrayInitStep(QualType T) { 2621 Step S; 2622 S.Kind = SK_ArrayInit; 2623 S.Type = T; 2624 Steps.push_back(S); 2625 } 2626 2627 void InitializationSequence::AddParenthesizedArrayInitStep(QualType T) { 2628 Step S; 2629 S.Kind = SK_ParenthesizedArrayInit; 2630 S.Type = T; 2631 Steps.push_back(S); 2632 } 2633 2634 void InitializationSequence::AddPassByIndirectCopyRestoreStep(QualType type, 2635 bool shouldCopy) { 2636 Step s; 2637 s.Kind = (shouldCopy ? SK_PassByIndirectCopyRestore 2638 : SK_PassByIndirectRestore); 2639 s.Type = type; 2640 Steps.push_back(s); 2641 } 2642 2643 void InitializationSequence::AddProduceObjCObjectStep(QualType T) { 2644 Step S; 2645 S.Kind = SK_ProduceObjCObject; 2646 S.Type = T; 2647 Steps.push_back(S); 2648 } 2649 2650 void InitializationSequence::AddStdInitializerListConstructionStep(QualType T) { 2651 Step S; 2652 S.Kind = SK_StdInitializerList; 2653 S.Type = T; 2654 Steps.push_back(S); 2655 } 2656 2657 void InitializationSequence::AddOCLSamplerInitStep(QualType T) { 2658 Step S; 2659 S.Kind = SK_OCLSamplerInit; 2660 S.Type = T; 2661 Steps.push_back(S); 2662 } 2663 2664 void InitializationSequence::AddOCLZeroEventStep(QualType T) { 2665 Step S; 2666 S.Kind = SK_OCLZeroEvent; 2667 S.Type = T; 2668 Steps.push_back(S); 2669 } 2670 2671 void InitializationSequence::RewrapReferenceInitList(QualType T, 2672 InitListExpr *Syntactic) { 2673 assert(Syntactic->getNumInits() == 1 && 2674 "Can only rewrap trivial init lists."); 2675 Step S; 2676 S.Kind = SK_UnwrapInitList; 2677 S.Type = Syntactic->getInit(0)->getType(); 2678 Steps.insert(Steps.begin(), S); 2679 2680 S.Kind = SK_RewrapInitList; 2681 S.Type = T; 2682 S.WrappingSyntacticList = Syntactic; 2683 Steps.push_back(S); 2684 } 2685 2686 void InitializationSequence::SetOverloadFailure(FailureKind Failure, 2687 OverloadingResult Result) { 2688 setSequenceKind(FailedSequence); 2689 this->Failure = Failure; 2690 this->FailedOverloadResult = Result; 2691 } 2692 2693 //===----------------------------------------------------------------------===// 2694 // Attempt initialization 2695 //===----------------------------------------------------------------------===// 2696 2697 static void MaybeProduceObjCObject(Sema &S, 2698 InitializationSequence &Sequence, 2699 const InitializedEntity &Entity) { 2700 if (!S.getLangOpts().ObjCAutoRefCount) return; 2701 2702 /// When initializing a parameter, produce the value if it's marked 2703 /// __attribute__((ns_consumed)). 2704 if (Entity.getKind() == InitializedEntity::EK_Parameter) { 2705 if (!Entity.isParameterConsumed()) 2706 return; 2707 2708 assert(Entity.getType()->isObjCRetainableType() && 2709 "consuming an object of unretainable type?"); 2710 Sequence.AddProduceObjCObjectStep(Entity.getType()); 2711 2712 /// When initializing a return value, if the return type is a 2713 /// retainable type, then returns need to immediately retain the 2714 /// object. If an autorelease is required, it will be done at the 2715 /// last instant. 2716 } else if (Entity.getKind() == InitializedEntity::EK_Result) { 2717 if (!Entity.getType()->isObjCRetainableType()) 2718 return; 2719 2720 Sequence.AddProduceObjCObjectStep(Entity.getType()); 2721 } 2722 } 2723 2724 /// \brief When initializing from init list via constructor, handle 2725 /// initialization of an object of type std::initializer_list<T>. 2726 /// 2727 /// \return true if we have handled initialization of an object of type 2728 /// std::initializer_list<T>, false otherwise. 2729 static bool TryInitializerListConstruction(Sema &S, 2730 InitListExpr *List, 2731 QualType DestType, 2732 InitializationSequence &Sequence) { 2733 QualType E; 2734 if (!S.isStdInitializerList(DestType, &E)) 2735 return false; 2736 2737 // Check that each individual element can be copy-constructed. But since we 2738 // have no place to store further information, we'll recalculate everything 2739 // later. 2740 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary( 2741 S.Context.getConstantArrayType(E, 2742 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()), 2743 List->getNumInits()), 2744 ArrayType::Normal, 0)); 2745 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context, 2746 0, HiddenArray); 2747 for (unsigned i = 0, n = List->getNumInits(); i < n; ++i) { 2748 Element.setElementIndex(i); 2749 if (!S.CanPerformCopyInitialization(Element, List->getInit(i))) { 2750 Sequence.SetFailed( 2751 InitializationSequence::FK_InitListElementCopyFailure); 2752 return true; 2753 } 2754 } 2755 Sequence.AddStdInitializerListConstructionStep(DestType); 2756 return true; 2757 } 2758 2759 static OverloadingResult 2760 ResolveConstructorOverload(Sema &S, SourceLocation DeclLoc, 2761 Expr **Args, unsigned NumArgs, 2762 OverloadCandidateSet &CandidateSet, 2763 ArrayRef<NamedDecl *> Ctors, 2764 OverloadCandidateSet::iterator &Best, 2765 bool CopyInitializing, bool AllowExplicit, 2766 bool OnlyListConstructors, bool InitListSyntax) { 2767 CandidateSet.clear(); 2768 2769 for (ArrayRef<NamedDecl *>::iterator 2770 Con = Ctors.begin(), ConEnd = Ctors.end(); Con != ConEnd; ++Con) { 2771 NamedDecl *D = *Con; 2772 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2773 bool SuppressUserConversions = false; 2774 2775 // Find the constructor (which may be a template). 2776 CXXConstructorDecl *Constructor = 0; 2777 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D); 2778 if (ConstructorTmpl) 2779 Constructor = cast<CXXConstructorDecl>( 2780 ConstructorTmpl->getTemplatedDecl()); 2781 else { 2782 Constructor = cast<CXXConstructorDecl>(D); 2783 2784 // If we're performing copy initialization using a copy constructor, we 2785 // suppress user-defined conversions on the arguments. We do the same for 2786 // move constructors. 2787 if ((CopyInitializing || (InitListSyntax && NumArgs == 1)) && 2788 Constructor->isCopyOrMoveConstructor()) 2789 SuppressUserConversions = true; 2790 } 2791 2792 if (!Constructor->isInvalidDecl() && 2793 (AllowExplicit || !Constructor->isExplicit()) && 2794 (!OnlyListConstructors || S.isInitListConstructor(Constructor))) { 2795 if (ConstructorTmpl) 2796 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2797 /*ExplicitArgs*/ 0, 2798 llvm::makeArrayRef(Args, NumArgs), 2799 CandidateSet, SuppressUserConversions); 2800 else { 2801 // C++ [over.match.copy]p1: 2802 // - When initializing a temporary to be bound to the first parameter 2803 // of a constructor that takes a reference to possibly cv-qualified 2804 // T as its first argument, called with a single argument in the 2805 // context of direct-initialization, explicit conversion functions 2806 // are also considered. 2807 bool AllowExplicitConv = AllowExplicit && !CopyInitializing && 2808 NumArgs == 1 && 2809 Constructor->isCopyOrMoveConstructor(); 2810 S.AddOverloadCandidate(Constructor, FoundDecl, 2811 llvm::makeArrayRef(Args, NumArgs), CandidateSet, 2812 SuppressUserConversions, 2813 /*PartialOverloading=*/false, 2814 /*AllowExplicit=*/AllowExplicitConv); 2815 } 2816 } 2817 } 2818 2819 // Perform overload resolution and return the result. 2820 return CandidateSet.BestViableFunction(S, DeclLoc, Best); 2821 } 2822 2823 /// \brief Attempt initialization by constructor (C++ [dcl.init]), which 2824 /// enumerates the constructors of the initialized entity and performs overload 2825 /// resolution to select the best. 2826 /// If InitListSyntax is true, this is list-initialization of a non-aggregate 2827 /// class type. 2828 static void TryConstructorInitialization(Sema &S, 2829 const InitializedEntity &Entity, 2830 const InitializationKind &Kind, 2831 Expr **Args, unsigned NumArgs, 2832 QualType DestType, 2833 InitializationSequence &Sequence, 2834 bool InitListSyntax = false) { 2835 assert((!InitListSyntax || (NumArgs == 1 && isa<InitListExpr>(Args[0]))) && 2836 "InitListSyntax must come with a single initializer list argument."); 2837 2838 // The type we're constructing needs to be complete. 2839 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) { 2840 Sequence.setIncompleteTypeFailure(DestType); 2841 return; 2842 } 2843 2844 const RecordType *DestRecordType = DestType->getAs<RecordType>(); 2845 assert(DestRecordType && "Constructor initialization requires record type"); 2846 CXXRecordDecl *DestRecordDecl 2847 = cast<CXXRecordDecl>(DestRecordType->getDecl()); 2848 2849 // Build the candidate set directly in the initialization sequence 2850 // structure, so that it will persist if we fail. 2851 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 2852 2853 // Determine whether we are allowed to call explicit constructors or 2854 // explicit conversion operators. 2855 bool AllowExplicit = Kind.AllowExplicit() || InitListSyntax; 2856 bool CopyInitialization = Kind.getKind() == InitializationKind::IK_Copy; 2857 2858 // - Otherwise, if T is a class type, constructors are considered. The 2859 // applicable constructors are enumerated, and the best one is chosen 2860 // through overload resolution. 2861 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl); 2862 // The container holding the constructors can under certain conditions 2863 // be changed while iterating (e.g. because of deserialization). 2864 // To be safe we copy the lookup results to a new container. 2865 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end()); 2866 2867 OverloadingResult Result = OR_No_Viable_Function; 2868 OverloadCandidateSet::iterator Best; 2869 bool AsInitializerList = false; 2870 2871 // C++11 [over.match.list]p1: 2872 // When objects of non-aggregate type T are list-initialized, overload 2873 // resolution selects the constructor in two phases: 2874 // - Initially, the candidate functions are the initializer-list 2875 // constructors of the class T and the argument list consists of the 2876 // initializer list as a single argument. 2877 if (InitListSyntax) { 2878 InitListExpr *ILE = cast<InitListExpr>(Args[0]); 2879 AsInitializerList = true; 2880 2881 // If the initializer list has no elements and T has a default constructor, 2882 // the first phase is omitted. 2883 if (ILE->getNumInits() != 0 || !DestRecordDecl->hasDefaultConstructor()) 2884 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, NumArgs, 2885 CandidateSet, Ctors, Best, 2886 CopyInitialization, AllowExplicit, 2887 /*OnlyListConstructor=*/true, 2888 InitListSyntax); 2889 2890 // Time to unwrap the init list. 2891 Args = ILE->getInits(); 2892 NumArgs = ILE->getNumInits(); 2893 } 2894 2895 // C++11 [over.match.list]p1: 2896 // - If no viable initializer-list constructor is found, overload resolution 2897 // is performed again, where the candidate functions are all the 2898 // constructors of the class T and the argument list consists of the 2899 // elements of the initializer list. 2900 if (Result == OR_No_Viable_Function) { 2901 AsInitializerList = false; 2902 Result = ResolveConstructorOverload(S, Kind.getLocation(), Args, NumArgs, 2903 CandidateSet, Ctors, Best, 2904 CopyInitialization, AllowExplicit, 2905 /*OnlyListConstructors=*/false, 2906 InitListSyntax); 2907 } 2908 if (Result) { 2909 Sequence.SetOverloadFailure(InitListSyntax ? 2910 InitializationSequence::FK_ListConstructorOverloadFailed : 2911 InitializationSequence::FK_ConstructorOverloadFailed, 2912 Result); 2913 return; 2914 } 2915 2916 // C++11 [dcl.init]p6: 2917 // If a program calls for the default initialization of an object 2918 // of a const-qualified type T, T shall be a class type with a 2919 // user-provided default constructor. 2920 if (Kind.getKind() == InitializationKind::IK_Default && 2921 Entity.getType().isConstQualified() && 2922 !cast<CXXConstructorDecl>(Best->Function)->isUserProvided()) { 2923 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst); 2924 return; 2925 } 2926 2927 // C++11 [over.match.list]p1: 2928 // In copy-list-initialization, if an explicit constructor is chosen, the 2929 // initializer is ill-formed. 2930 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function); 2931 if (InitListSyntax && !Kind.AllowExplicit() && CtorDecl->isExplicit()) { 2932 Sequence.SetFailed(InitializationSequence::FK_ExplicitConstructor); 2933 return; 2934 } 2935 2936 // Add the constructor initialization step. Any cv-qualification conversion is 2937 // subsumed by the initialization. 2938 bool HadMultipleCandidates = (CandidateSet.size() > 1); 2939 Sequence.AddConstructorInitializationStep(CtorDecl, 2940 Best->FoundDecl.getAccess(), 2941 DestType, HadMultipleCandidates, 2942 InitListSyntax, AsInitializerList); 2943 } 2944 2945 static bool 2946 ResolveOverloadedFunctionForReferenceBinding(Sema &S, 2947 Expr *Initializer, 2948 QualType &SourceType, 2949 QualType &UnqualifiedSourceType, 2950 QualType UnqualifiedTargetType, 2951 InitializationSequence &Sequence) { 2952 if (S.Context.getCanonicalType(UnqualifiedSourceType) == 2953 S.Context.OverloadTy) { 2954 DeclAccessPair Found; 2955 bool HadMultipleCandidates = false; 2956 if (FunctionDecl *Fn 2957 = S.ResolveAddressOfOverloadedFunction(Initializer, 2958 UnqualifiedTargetType, 2959 false, Found, 2960 &HadMultipleCandidates)) { 2961 Sequence.AddAddressOverloadResolutionStep(Fn, Found, 2962 HadMultipleCandidates); 2963 SourceType = Fn->getType(); 2964 UnqualifiedSourceType = SourceType.getUnqualifiedType(); 2965 } else if (!UnqualifiedTargetType->isRecordType()) { 2966 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 2967 return true; 2968 } 2969 } 2970 return false; 2971 } 2972 2973 static void TryReferenceInitializationCore(Sema &S, 2974 const InitializedEntity &Entity, 2975 const InitializationKind &Kind, 2976 Expr *Initializer, 2977 QualType cv1T1, QualType T1, 2978 Qualifiers T1Quals, 2979 QualType cv2T2, QualType T2, 2980 Qualifiers T2Quals, 2981 InitializationSequence &Sequence); 2982 2983 static void TryValueInitialization(Sema &S, 2984 const InitializedEntity &Entity, 2985 const InitializationKind &Kind, 2986 InitializationSequence &Sequence, 2987 InitListExpr *InitList = 0); 2988 2989 static void TryListInitialization(Sema &S, 2990 const InitializedEntity &Entity, 2991 const InitializationKind &Kind, 2992 InitListExpr *InitList, 2993 InitializationSequence &Sequence); 2994 2995 /// \brief Attempt list initialization of a reference. 2996 static void TryReferenceListInitialization(Sema &S, 2997 const InitializedEntity &Entity, 2998 const InitializationKind &Kind, 2999 InitListExpr *InitList, 3000 InitializationSequence &Sequence) 3001 { 3002 // First, catch C++03 where this isn't possible. 3003 if (!S.getLangOpts().CPlusPlus11) { 3004 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList); 3005 return; 3006 } 3007 3008 QualType DestType = Entity.getType(); 3009 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 3010 Qualifiers T1Quals; 3011 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals); 3012 3013 // Reference initialization via an initializer list works thus: 3014 // If the initializer list consists of a single element that is 3015 // reference-related to the referenced type, bind directly to that element 3016 // (possibly creating temporaries). 3017 // Otherwise, initialize a temporary with the initializer list and 3018 // bind to that. 3019 if (InitList->getNumInits() == 1) { 3020 Expr *Initializer = InitList->getInit(0); 3021 QualType cv2T2 = Initializer->getType(); 3022 Qualifiers T2Quals; 3023 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals); 3024 3025 // If this fails, creating a temporary wouldn't work either. 3026 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2, 3027 T1, Sequence)) 3028 return; 3029 3030 SourceLocation DeclLoc = Initializer->getLocStart(); 3031 bool dummy1, dummy2, dummy3; 3032 Sema::ReferenceCompareResult RefRelationship 3033 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, dummy1, 3034 dummy2, dummy3); 3035 if (RefRelationship >= Sema::Ref_Related) { 3036 // Try to bind the reference here. 3037 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1, 3038 T1Quals, cv2T2, T2, T2Quals, Sequence); 3039 if (Sequence) 3040 Sequence.RewrapReferenceInitList(cv1T1, InitList); 3041 return; 3042 } 3043 3044 // Update the initializer if we've resolved an overloaded function. 3045 if (Sequence.step_begin() != Sequence.step_end()) 3046 Sequence.RewrapReferenceInitList(cv1T1, InitList); 3047 } 3048 3049 // Not reference-related. Create a temporary and bind to that. 3050 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1); 3051 3052 TryListInitialization(S, TempEntity, Kind, InitList, Sequence); 3053 if (Sequence) { 3054 if (DestType->isRValueReferenceType() || 3055 (T1Quals.hasConst() && !T1Quals.hasVolatile())) 3056 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); 3057 else 3058 Sequence.SetFailed( 3059 InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary); 3060 } 3061 } 3062 3063 /// \brief Attempt list initialization (C++0x [dcl.init.list]) 3064 static void TryListInitialization(Sema &S, 3065 const InitializedEntity &Entity, 3066 const InitializationKind &Kind, 3067 InitListExpr *InitList, 3068 InitializationSequence &Sequence) { 3069 QualType DestType = Entity.getType(); 3070 3071 // C++ doesn't allow scalar initialization with more than one argument. 3072 // But C99 complex numbers are scalars and it makes sense there. 3073 if (S.getLangOpts().CPlusPlus && DestType->isScalarType() && 3074 !DestType->isAnyComplexType() && InitList->getNumInits() > 1) { 3075 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar); 3076 return; 3077 } 3078 if (DestType->isReferenceType()) { 3079 TryReferenceListInitialization(S, Entity, Kind, InitList, Sequence); 3080 return; 3081 } 3082 if (DestType->isRecordType()) { 3083 if (S.RequireCompleteType(InitList->getLocStart(), DestType, 0)) { 3084 Sequence.setIncompleteTypeFailure(DestType); 3085 return; 3086 } 3087 3088 // C++11 [dcl.init.list]p3: 3089 // - If T is an aggregate, aggregate initialization is performed. 3090 if (!DestType->isAggregateType()) { 3091 if (S.getLangOpts().CPlusPlus11) { 3092 // - Otherwise, if the initializer list has no elements and T is a 3093 // class type with a default constructor, the object is 3094 // value-initialized. 3095 if (InitList->getNumInits() == 0) { 3096 CXXRecordDecl *RD = DestType->getAsCXXRecordDecl(); 3097 if (RD->hasDefaultConstructor()) { 3098 TryValueInitialization(S, Entity, Kind, Sequence, InitList); 3099 return; 3100 } 3101 } 3102 3103 // - Otherwise, if T is a specialization of std::initializer_list<E>, 3104 // an initializer_list object constructed [...] 3105 if (TryInitializerListConstruction(S, InitList, DestType, Sequence)) 3106 return; 3107 3108 // - Otherwise, if T is a class type, constructors are considered. 3109 Expr *Arg = InitList; 3110 TryConstructorInitialization(S, Entity, Kind, &Arg, 1, DestType, 3111 Sequence, /*InitListSyntax*/true); 3112 } else 3113 Sequence.SetFailed( 3114 InitializationSequence::FK_InitListBadDestinationType); 3115 return; 3116 } 3117 } 3118 3119 InitListChecker CheckInitList(S, Entity, InitList, 3120 DestType, /*VerifyOnly=*/true, 3121 Kind.getKind() != InitializationKind::IK_DirectList || 3122 !S.getLangOpts().CPlusPlus11); 3123 if (CheckInitList.HadError()) { 3124 Sequence.SetFailed(InitializationSequence::FK_ListInitializationFailed); 3125 return; 3126 } 3127 3128 // Add the list initialization step with the built init list. 3129 Sequence.AddListInitializationStep(DestType); 3130 } 3131 3132 /// \brief Try a reference initialization that involves calling a conversion 3133 /// function. 3134 static OverloadingResult TryRefInitWithConversionFunction(Sema &S, 3135 const InitializedEntity &Entity, 3136 const InitializationKind &Kind, 3137 Expr *Initializer, 3138 bool AllowRValues, 3139 InitializationSequence &Sequence) { 3140 QualType DestType = Entity.getType(); 3141 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 3142 QualType T1 = cv1T1.getUnqualifiedType(); 3143 QualType cv2T2 = Initializer->getType(); 3144 QualType T2 = cv2T2.getUnqualifiedType(); 3145 3146 bool DerivedToBase; 3147 bool ObjCConversion; 3148 bool ObjCLifetimeConversion; 3149 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(), 3150 T1, T2, DerivedToBase, 3151 ObjCConversion, 3152 ObjCLifetimeConversion) && 3153 "Must have incompatible references when binding via conversion"); 3154 (void)DerivedToBase; 3155 (void)ObjCConversion; 3156 (void)ObjCLifetimeConversion; 3157 3158 // Build the candidate set directly in the initialization sequence 3159 // structure, so that it will persist if we fail. 3160 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 3161 CandidateSet.clear(); 3162 3163 // Determine whether we are allowed to call explicit constructors or 3164 // explicit conversion operators. 3165 bool AllowExplicit = Kind.AllowExplicit(); 3166 bool AllowExplicitConvs = Kind.allowExplicitConversionFunctions(); 3167 3168 const RecordType *T1RecordType = 0; 3169 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) && 3170 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) { 3171 // The type we're converting to is a class type. Enumerate its constructors 3172 // to see if there is a suitable conversion. 3173 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl()); 3174 3175 DeclContext::lookup_result R = S.LookupConstructors(T1RecordDecl); 3176 // The container holding the constructors can under certain conditions 3177 // be changed while iterating (e.g. because of deserialization). 3178 // To be safe we copy the lookup results to a new container. 3179 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end()); 3180 for (SmallVector<NamedDecl*, 16>::iterator 3181 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) { 3182 NamedDecl *D = *CI; 3183 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 3184 3185 // Find the constructor (which may be a template). 3186 CXXConstructorDecl *Constructor = 0; 3187 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D); 3188 if (ConstructorTmpl) 3189 Constructor = cast<CXXConstructorDecl>( 3190 ConstructorTmpl->getTemplatedDecl()); 3191 else 3192 Constructor = cast<CXXConstructorDecl>(D); 3193 3194 if (!Constructor->isInvalidDecl() && 3195 Constructor->isConvertingConstructor(AllowExplicit)) { 3196 if (ConstructorTmpl) 3197 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 3198 /*ExplicitArgs*/ 0, 3199 Initializer, CandidateSet, 3200 /*SuppressUserConversions=*/true); 3201 else 3202 S.AddOverloadCandidate(Constructor, FoundDecl, 3203 Initializer, CandidateSet, 3204 /*SuppressUserConversions=*/true); 3205 } 3206 } 3207 } 3208 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl()) 3209 return OR_No_Viable_Function; 3210 3211 const RecordType *T2RecordType = 0; 3212 if ((T2RecordType = T2->getAs<RecordType>()) && 3213 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) { 3214 // The type we're converting from is a class type, enumerate its conversion 3215 // functions. 3216 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl()); 3217 3218 std::pair<CXXRecordDecl::conversion_iterator, 3219 CXXRecordDecl::conversion_iterator> 3220 Conversions = T2RecordDecl->getVisibleConversionFunctions(); 3221 for (CXXRecordDecl::conversion_iterator 3222 I = Conversions.first, E = Conversions.second; I != E; ++I) { 3223 NamedDecl *D = *I; 3224 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 3225 if (isa<UsingShadowDecl>(D)) 3226 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 3227 3228 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 3229 CXXConversionDecl *Conv; 3230 if (ConvTemplate) 3231 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 3232 else 3233 Conv = cast<CXXConversionDecl>(D); 3234 3235 // If the conversion function doesn't return a reference type, 3236 // it can't be considered for this conversion unless we're allowed to 3237 // consider rvalues. 3238 // FIXME: Do we need to make sure that we only consider conversion 3239 // candidates with reference-compatible results? That might be needed to 3240 // break recursion. 3241 if ((AllowExplicitConvs || !Conv->isExplicit()) && 3242 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){ 3243 if (ConvTemplate) 3244 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), 3245 ActingDC, Initializer, 3246 DestType, CandidateSet); 3247 else 3248 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, 3249 Initializer, DestType, CandidateSet); 3250 } 3251 } 3252 } 3253 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl()) 3254 return OR_No_Viable_Function; 3255 3256 SourceLocation DeclLoc = Initializer->getLocStart(); 3257 3258 // Perform overload resolution. If it fails, return the failed result. 3259 OverloadCandidateSet::iterator Best; 3260 if (OverloadingResult Result 3261 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) 3262 return Result; 3263 3264 FunctionDecl *Function = Best->Function; 3265 // This is the overload that will be used for this initialization step if we 3266 // use this initialization. Mark it as referenced. 3267 Function->setReferenced(); 3268 3269 // Compute the returned type of the conversion. 3270 if (isa<CXXConversionDecl>(Function)) 3271 T2 = Function->getResultType(); 3272 else 3273 T2 = cv1T1; 3274 3275 // Add the user-defined conversion step. 3276 bool HadMultipleCandidates = (CandidateSet.size() > 1); 3277 Sequence.AddUserConversionStep(Function, Best->FoundDecl, 3278 T2.getNonLValueExprType(S.Context), 3279 HadMultipleCandidates); 3280 3281 // Determine whether we need to perform derived-to-base or 3282 // cv-qualification adjustments. 3283 ExprValueKind VK = VK_RValue; 3284 if (T2->isLValueReferenceType()) 3285 VK = VK_LValue; 3286 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>()) 3287 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue; 3288 3289 bool NewDerivedToBase = false; 3290 bool NewObjCConversion = false; 3291 bool NewObjCLifetimeConversion = false; 3292 Sema::ReferenceCompareResult NewRefRelationship 3293 = S.CompareReferenceRelationship(DeclLoc, T1, 3294 T2.getNonLValueExprType(S.Context), 3295 NewDerivedToBase, NewObjCConversion, 3296 NewObjCLifetimeConversion); 3297 if (NewRefRelationship == Sema::Ref_Incompatible) { 3298 // If the type we've converted to is not reference-related to the 3299 // type we're looking for, then there is another conversion step 3300 // we need to perform to produce a temporary of the right type 3301 // that we'll be binding to. 3302 ImplicitConversionSequence ICS; 3303 ICS.setStandard(); 3304 ICS.Standard = Best->FinalConversion; 3305 T2 = ICS.Standard.getToType(2); 3306 Sequence.AddConversionSequenceStep(ICS, T2); 3307 } else if (NewDerivedToBase) 3308 Sequence.AddDerivedToBaseCastStep( 3309 S.Context.getQualifiedType(T1, 3310 T2.getNonReferenceType().getQualifiers()), 3311 VK); 3312 else if (NewObjCConversion) 3313 Sequence.AddObjCObjectConversionStep( 3314 S.Context.getQualifiedType(T1, 3315 T2.getNonReferenceType().getQualifiers())); 3316 3317 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers()) 3318 Sequence.AddQualificationConversionStep(cv1T1, VK); 3319 3320 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType()); 3321 return OR_Success; 3322 } 3323 3324 static void CheckCXX98CompatAccessibleCopy(Sema &S, 3325 const InitializedEntity &Entity, 3326 Expr *CurInitExpr); 3327 3328 /// \brief Attempt reference initialization (C++0x [dcl.init.ref]) 3329 static void TryReferenceInitialization(Sema &S, 3330 const InitializedEntity &Entity, 3331 const InitializationKind &Kind, 3332 Expr *Initializer, 3333 InitializationSequence &Sequence) { 3334 QualType DestType = Entity.getType(); 3335 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 3336 Qualifiers T1Quals; 3337 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals); 3338 QualType cv2T2 = Initializer->getType(); 3339 Qualifiers T2Quals; 3340 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals); 3341 3342 // If the initializer is the address of an overloaded function, try 3343 // to resolve the overloaded function. If all goes well, T2 is the 3344 // type of the resulting function. 3345 if (ResolveOverloadedFunctionForReferenceBinding(S, Initializer, cv2T2, T2, 3346 T1, Sequence)) 3347 return; 3348 3349 // Delegate everything else to a subfunction. 3350 TryReferenceInitializationCore(S, Entity, Kind, Initializer, cv1T1, T1, 3351 T1Quals, cv2T2, T2, T2Quals, Sequence); 3352 } 3353 3354 /// \brief Reference initialization without resolving overloaded functions. 3355 static void TryReferenceInitializationCore(Sema &S, 3356 const InitializedEntity &Entity, 3357 const InitializationKind &Kind, 3358 Expr *Initializer, 3359 QualType cv1T1, QualType T1, 3360 Qualifiers T1Quals, 3361 QualType cv2T2, QualType T2, 3362 Qualifiers T2Quals, 3363 InitializationSequence &Sequence) { 3364 QualType DestType = Entity.getType(); 3365 SourceLocation DeclLoc = Initializer->getLocStart(); 3366 // Compute some basic properties of the types and the initializer. 3367 bool isLValueRef = DestType->isLValueReferenceType(); 3368 bool isRValueRef = !isLValueRef; 3369 bool DerivedToBase = false; 3370 bool ObjCConversion = false; 3371 bool ObjCLifetimeConversion = false; 3372 Expr::Classification InitCategory = Initializer->Classify(S.Context); 3373 Sema::ReferenceCompareResult RefRelationship 3374 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase, 3375 ObjCConversion, ObjCLifetimeConversion); 3376 3377 // C++0x [dcl.init.ref]p5: 3378 // A reference to type "cv1 T1" is initialized by an expression of type 3379 // "cv2 T2" as follows: 3380 // 3381 // - If the reference is an lvalue reference and the initializer 3382 // expression 3383 // Note the analogous bullet points for rvlaue refs to functions. Because 3384 // there are no function rvalues in C++, rvalue refs to functions are treated 3385 // like lvalue refs. 3386 OverloadingResult ConvOvlResult = OR_Success; 3387 bool T1Function = T1->isFunctionType(); 3388 if (isLValueRef || T1Function) { 3389 if (InitCategory.isLValue() && 3390 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification || 3391 (Kind.isCStyleOrFunctionalCast() && 3392 RefRelationship == Sema::Ref_Related))) { 3393 // - is an lvalue (but is not a bit-field), and "cv1 T1" is 3394 // reference-compatible with "cv2 T2," or 3395 // 3396 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a 3397 // bit-field when we're determining whether the reference initialization 3398 // can occur. However, we do pay attention to whether it is a bit-field 3399 // to decide whether we're actually binding to a temporary created from 3400 // the bit-field. 3401 if (DerivedToBase) 3402 Sequence.AddDerivedToBaseCastStep( 3403 S.Context.getQualifiedType(T1, T2Quals), 3404 VK_LValue); 3405 else if (ObjCConversion) 3406 Sequence.AddObjCObjectConversionStep( 3407 S.Context.getQualifiedType(T1, T2Quals)); 3408 3409 if (T1Quals != T2Quals) 3410 Sequence.AddQualificationConversionStep(cv1T1, VK_LValue); 3411 bool BindingTemporary = T1Quals.hasConst() && !T1Quals.hasVolatile() && 3412 (Initializer->getBitField() || Initializer->refersToVectorElement()); 3413 Sequence.AddReferenceBindingStep(cv1T1, BindingTemporary); 3414 return; 3415 } 3416 3417 // - has a class type (i.e., T2 is a class type), where T1 is not 3418 // reference-related to T2, and can be implicitly converted to an 3419 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible 3420 // with "cv3 T3" (this conversion is selected by enumerating the 3421 // applicable conversion functions (13.3.1.6) and choosing the best 3422 // one through overload resolution (13.3)), 3423 // If we have an rvalue ref to function type here, the rhs must be 3424 // an rvalue. 3425 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() && 3426 (isLValueRef || InitCategory.isRValue())) { 3427 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind, 3428 Initializer, 3429 /*AllowRValues=*/isRValueRef, 3430 Sequence); 3431 if (ConvOvlResult == OR_Success) 3432 return; 3433 if (ConvOvlResult != OR_No_Viable_Function) { 3434 Sequence.SetOverloadFailure( 3435 InitializationSequence::FK_ReferenceInitOverloadFailed, 3436 ConvOvlResult); 3437 } 3438 } 3439 } 3440 3441 // - Otherwise, the reference shall be an lvalue reference to a 3442 // non-volatile const type (i.e., cv1 shall be const), or the reference 3443 // shall be an rvalue reference. 3444 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) { 3445 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 3446 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 3447 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 3448 Sequence.SetOverloadFailure( 3449 InitializationSequence::FK_ReferenceInitOverloadFailed, 3450 ConvOvlResult); 3451 else 3452 Sequence.SetFailed(InitCategory.isLValue() 3453 ? (RefRelationship == Sema::Ref_Related 3454 ? InitializationSequence::FK_ReferenceInitDropsQualifiers 3455 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated) 3456 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary); 3457 3458 return; 3459 } 3460 3461 // - If the initializer expression 3462 // - is an xvalue, class prvalue, array prvalue, or function lvalue and 3463 // "cv1 T1" is reference-compatible with "cv2 T2" 3464 // Note: functions are handled below. 3465 if (!T1Function && 3466 (RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification || 3467 (Kind.isCStyleOrFunctionalCast() && 3468 RefRelationship == Sema::Ref_Related)) && 3469 (InitCategory.isXValue() || 3470 (InitCategory.isPRValue() && T2->isRecordType()) || 3471 (InitCategory.isPRValue() && T2->isArrayType()))) { 3472 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue; 3473 if (InitCategory.isPRValue() && T2->isRecordType()) { 3474 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the 3475 // compiler the freedom to perform a copy here or bind to the 3476 // object, while C++0x requires that we bind directly to the 3477 // object. Hence, we always bind to the object without making an 3478 // extra copy. However, in C++03 requires that we check for the 3479 // presence of a suitable copy constructor: 3480 // 3481 // The constructor that would be used to make the copy shall 3482 // be callable whether or not the copy is actually done. 3483 if (!S.getLangOpts().CPlusPlus11 && !S.getLangOpts().MicrosoftExt) 3484 Sequence.AddExtraneousCopyToTemporary(cv2T2); 3485 else if (S.getLangOpts().CPlusPlus11) 3486 CheckCXX98CompatAccessibleCopy(S, Entity, Initializer); 3487 } 3488 3489 if (DerivedToBase) 3490 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals), 3491 ValueKind); 3492 else if (ObjCConversion) 3493 Sequence.AddObjCObjectConversionStep( 3494 S.Context.getQualifiedType(T1, T2Quals)); 3495 3496 if (T1Quals != T2Quals) 3497 Sequence.AddQualificationConversionStep(cv1T1, ValueKind); 3498 Sequence.AddReferenceBindingStep(cv1T1, 3499 /*bindingTemporary=*/InitCategory.isPRValue()); 3500 return; 3501 } 3502 3503 // - has a class type (i.e., T2 is a class type), where T1 is not 3504 // reference-related to T2, and can be implicitly converted to an 3505 // xvalue, class prvalue, or function lvalue of type "cv3 T3", 3506 // where "cv1 T1" is reference-compatible with "cv3 T3", 3507 if (T2->isRecordType()) { 3508 if (RefRelationship == Sema::Ref_Incompatible) { 3509 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, 3510 Kind, Initializer, 3511 /*AllowRValues=*/true, 3512 Sequence); 3513 if (ConvOvlResult) 3514 Sequence.SetOverloadFailure( 3515 InitializationSequence::FK_ReferenceInitOverloadFailed, 3516 ConvOvlResult); 3517 3518 return; 3519 } 3520 3521 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 3522 return; 3523 } 3524 3525 // - Otherwise, a temporary of type "cv1 T1" is created and initialized 3526 // from the initializer expression using the rules for a non-reference 3527 // copy initialization (8.5). The reference is then bound to the 3528 // temporary. [...] 3529 3530 // Determine whether we are allowed to call explicit constructors or 3531 // explicit conversion operators. 3532 bool AllowExplicit = Kind.AllowExplicit(); 3533 3534 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1); 3535 3536 ImplicitConversionSequence ICS 3537 = S.TryImplicitConversion(Initializer, TempEntity.getType(), 3538 /*SuppressUserConversions*/ false, 3539 AllowExplicit, 3540 /*FIXME:InOverloadResolution=*/false, 3541 /*CStyle=*/Kind.isCStyleOrFunctionalCast(), 3542 /*AllowObjCWritebackConversion=*/false); 3543 3544 if (ICS.isBad()) { 3545 // FIXME: Use the conversion function set stored in ICS to turn 3546 // this into an overloading ambiguity diagnostic. However, we need 3547 // to keep that set as an OverloadCandidateSet rather than as some 3548 // other kind of set. 3549 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 3550 Sequence.SetOverloadFailure( 3551 InitializationSequence::FK_ReferenceInitOverloadFailed, 3552 ConvOvlResult); 3553 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 3554 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 3555 else 3556 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed); 3557 return; 3558 } else { 3559 Sequence.AddConversionSequenceStep(ICS, TempEntity.getType()); 3560 } 3561 3562 // [...] If T1 is reference-related to T2, cv1 must be the 3563 // same cv-qualification as, or greater cv-qualification 3564 // than, cv2; otherwise, the program is ill-formed. 3565 unsigned T1CVRQuals = T1Quals.getCVRQualifiers(); 3566 unsigned T2CVRQuals = T2Quals.getCVRQualifiers(); 3567 if (RefRelationship == Sema::Ref_Related && 3568 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) { 3569 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 3570 return; 3571 } 3572 3573 // [...] If T1 is reference-related to T2 and the reference is an rvalue 3574 // reference, the initializer expression shall not be an lvalue. 3575 if (RefRelationship >= Sema::Ref_Related && !isLValueRef && 3576 InitCategory.isLValue()) { 3577 Sequence.SetFailed( 3578 InitializationSequence::FK_RValueReferenceBindingToLValue); 3579 return; 3580 } 3581 3582 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); 3583 return; 3584 } 3585 3586 /// \brief Attempt character array initialization from a string literal 3587 /// (C++ [dcl.init.string], C99 6.7.8). 3588 static void TryStringLiteralInitialization(Sema &S, 3589 const InitializedEntity &Entity, 3590 const InitializationKind &Kind, 3591 Expr *Initializer, 3592 InitializationSequence &Sequence) { 3593 Sequence.AddStringInitStep(Entity.getType()); 3594 } 3595 3596 /// \brief Attempt value initialization (C++ [dcl.init]p7). 3597 static void TryValueInitialization(Sema &S, 3598 const InitializedEntity &Entity, 3599 const InitializationKind &Kind, 3600 InitializationSequence &Sequence, 3601 InitListExpr *InitList) { 3602 assert((!InitList || InitList->getNumInits() == 0) && 3603 "Shouldn't use value-init for non-empty init lists"); 3604 3605 // C++98 [dcl.init]p5, C++11 [dcl.init]p7: 3606 // 3607 // To value-initialize an object of type T means: 3608 QualType T = Entity.getType(); 3609 3610 // -- if T is an array type, then each element is value-initialized; 3611 T = S.Context.getBaseElementType(T); 3612 3613 if (const RecordType *RT = T->getAs<RecordType>()) { 3614 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 3615 bool NeedZeroInitialization = true; 3616 if (!S.getLangOpts().CPlusPlus11) { 3617 // C++98: 3618 // -- if T is a class type (clause 9) with a user-declared constructor 3619 // (12.1), then the default constructor for T is called (and the 3620 // initialization is ill-formed if T has no accessible default 3621 // constructor); 3622 if (ClassDecl->hasUserDeclaredConstructor()) 3623 NeedZeroInitialization = false; 3624 } else { 3625 // C++11: 3626 // -- if T is a class type (clause 9) with either no default constructor 3627 // (12.1 [class.ctor]) or a default constructor that is user-provided 3628 // or deleted, then the object is default-initialized; 3629 CXXConstructorDecl *CD = S.LookupDefaultConstructor(ClassDecl); 3630 if (!CD || !CD->getCanonicalDecl()->isDefaulted() || CD->isDeleted()) 3631 NeedZeroInitialization = false; 3632 } 3633 3634 // -- if T is a (possibly cv-qualified) non-union class type without a 3635 // user-provided or deleted default constructor, then the object is 3636 // zero-initialized and, if T has a non-trivial default constructor, 3637 // default-initialized; 3638 // The 'non-union' here was removed by DR1502. The 'non-trivial default 3639 // constructor' part was removed by DR1507. 3640 if (NeedZeroInitialization) 3641 Sequence.AddZeroInitializationStep(Entity.getType()); 3642 3643 // C++03: 3644 // -- if T is a non-union class type without a user-declared constructor, 3645 // then every non-static data member and base class component of T is 3646 // value-initialized; 3647 // [...] A program that calls for [...] value-initialization of an 3648 // entity of reference type is ill-formed. 3649 // 3650 // C++11 doesn't need this handling, because value-initialization does not 3651 // occur recursively there, and the implicit default constructor is 3652 // defined as deleted in the problematic cases. 3653 if (!S.getLangOpts().CPlusPlus11 && 3654 ClassDecl->hasUninitializedReferenceMember()) { 3655 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForReference); 3656 return; 3657 } 3658 3659 // If this is list-value-initialization, pass the empty init list on when 3660 // building the constructor call. This affects the semantics of a few 3661 // things (such as whether an explicit default constructor can be called). 3662 Expr *InitListAsExpr = InitList; 3663 Expr **Args = InitList ? &InitListAsExpr : 0; 3664 unsigned NumArgs = InitList ? 1 : 0; 3665 bool InitListSyntax = InitList; 3666 3667 return TryConstructorInitialization(S, Entity, Kind, Args, NumArgs, T, 3668 Sequence, InitListSyntax); 3669 } 3670 } 3671 3672 Sequence.AddZeroInitializationStep(Entity.getType()); 3673 } 3674 3675 /// \brief Attempt default initialization (C++ [dcl.init]p6). 3676 static void TryDefaultInitialization(Sema &S, 3677 const InitializedEntity &Entity, 3678 const InitializationKind &Kind, 3679 InitializationSequence &Sequence) { 3680 assert(Kind.getKind() == InitializationKind::IK_Default); 3681 3682 // C++ [dcl.init]p6: 3683 // To default-initialize an object of type T means: 3684 // - if T is an array type, each element is default-initialized; 3685 QualType DestType = S.Context.getBaseElementType(Entity.getType()); 3686 3687 // - if T is a (possibly cv-qualified) class type (Clause 9), the default 3688 // constructor for T is called (and the initialization is ill-formed if 3689 // T has no accessible default constructor); 3690 if (DestType->isRecordType() && S.getLangOpts().CPlusPlus) { 3691 TryConstructorInitialization(S, Entity, Kind, 0, 0, DestType, Sequence); 3692 return; 3693 } 3694 3695 // - otherwise, no initialization is performed. 3696 3697 // If a program calls for the default initialization of an object of 3698 // a const-qualified type T, T shall be a class type with a user-provided 3699 // default constructor. 3700 if (DestType.isConstQualified() && S.getLangOpts().CPlusPlus) { 3701 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst); 3702 return; 3703 } 3704 3705 // If the destination type has a lifetime property, zero-initialize it. 3706 if (DestType.getQualifiers().hasObjCLifetime()) { 3707 Sequence.AddZeroInitializationStep(Entity.getType()); 3708 return; 3709 } 3710 } 3711 3712 /// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]), 3713 /// which enumerates all conversion functions and performs overload resolution 3714 /// to select the best. 3715 static void TryUserDefinedConversion(Sema &S, 3716 const InitializedEntity &Entity, 3717 const InitializationKind &Kind, 3718 Expr *Initializer, 3719 InitializationSequence &Sequence) { 3720 QualType DestType = Entity.getType(); 3721 assert(!DestType->isReferenceType() && "References are handled elsewhere"); 3722 QualType SourceType = Initializer->getType(); 3723 assert((DestType->isRecordType() || SourceType->isRecordType()) && 3724 "Must have a class type to perform a user-defined conversion"); 3725 3726 // Build the candidate set directly in the initialization sequence 3727 // structure, so that it will persist if we fail. 3728 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 3729 CandidateSet.clear(); 3730 3731 // Determine whether we are allowed to call explicit constructors or 3732 // explicit conversion operators. 3733 bool AllowExplicit = Kind.AllowExplicit(); 3734 3735 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) { 3736 // The type we're converting to is a class type. Enumerate its constructors 3737 // to see if there is a suitable conversion. 3738 CXXRecordDecl *DestRecordDecl 3739 = cast<CXXRecordDecl>(DestRecordType->getDecl()); 3740 3741 // Try to complete the type we're converting to. 3742 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) { 3743 DeclContext::lookup_result R = S.LookupConstructors(DestRecordDecl); 3744 // The container holding the constructors can under certain conditions 3745 // be changed while iterating. To be safe we copy the lookup results 3746 // to a new container. 3747 SmallVector<NamedDecl*, 8> CopyOfCon(R.begin(), R.end()); 3748 for (SmallVector<NamedDecl*, 8>::iterator 3749 Con = CopyOfCon.begin(), ConEnd = CopyOfCon.end(); 3750 Con != ConEnd; ++Con) { 3751 NamedDecl *D = *Con; 3752 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 3753 3754 // Find the constructor (which may be a template). 3755 CXXConstructorDecl *Constructor = 0; 3756 FunctionTemplateDecl *ConstructorTmpl 3757 = dyn_cast<FunctionTemplateDecl>(D); 3758 if (ConstructorTmpl) 3759 Constructor = cast<CXXConstructorDecl>( 3760 ConstructorTmpl->getTemplatedDecl()); 3761 else 3762 Constructor = cast<CXXConstructorDecl>(D); 3763 3764 if (!Constructor->isInvalidDecl() && 3765 Constructor->isConvertingConstructor(AllowExplicit)) { 3766 if (ConstructorTmpl) 3767 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 3768 /*ExplicitArgs*/ 0, 3769 Initializer, CandidateSet, 3770 /*SuppressUserConversions=*/true); 3771 else 3772 S.AddOverloadCandidate(Constructor, FoundDecl, 3773 Initializer, CandidateSet, 3774 /*SuppressUserConversions=*/true); 3775 } 3776 } 3777 } 3778 } 3779 3780 SourceLocation DeclLoc = Initializer->getLocStart(); 3781 3782 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) { 3783 // The type we're converting from is a class type, enumerate its conversion 3784 // functions. 3785 3786 // We can only enumerate the conversion functions for a complete type; if 3787 // the type isn't complete, simply skip this step. 3788 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) { 3789 CXXRecordDecl *SourceRecordDecl 3790 = cast<CXXRecordDecl>(SourceRecordType->getDecl()); 3791 3792 std::pair<CXXRecordDecl::conversion_iterator, 3793 CXXRecordDecl::conversion_iterator> 3794 Conversions = SourceRecordDecl->getVisibleConversionFunctions(); 3795 for (CXXRecordDecl::conversion_iterator 3796 I = Conversions.first, E = Conversions.second; I != E; ++I) { 3797 NamedDecl *D = *I; 3798 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 3799 if (isa<UsingShadowDecl>(D)) 3800 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 3801 3802 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 3803 CXXConversionDecl *Conv; 3804 if (ConvTemplate) 3805 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 3806 else 3807 Conv = cast<CXXConversionDecl>(D); 3808 3809 if (AllowExplicit || !Conv->isExplicit()) { 3810 if (ConvTemplate) 3811 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), 3812 ActingDC, Initializer, DestType, 3813 CandidateSet); 3814 else 3815 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, 3816 Initializer, DestType, CandidateSet); 3817 } 3818 } 3819 } 3820 } 3821 3822 // Perform overload resolution. If it fails, return the failed result. 3823 OverloadCandidateSet::iterator Best; 3824 if (OverloadingResult Result 3825 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) { 3826 Sequence.SetOverloadFailure( 3827 InitializationSequence::FK_UserConversionOverloadFailed, 3828 Result); 3829 return; 3830 } 3831 3832 FunctionDecl *Function = Best->Function; 3833 Function->setReferenced(); 3834 bool HadMultipleCandidates = (CandidateSet.size() > 1); 3835 3836 if (isa<CXXConstructorDecl>(Function)) { 3837 // Add the user-defined conversion step. Any cv-qualification conversion is 3838 // subsumed by the initialization. Per DR5, the created temporary is of the 3839 // cv-unqualified type of the destination. 3840 Sequence.AddUserConversionStep(Function, Best->FoundDecl, 3841 DestType.getUnqualifiedType(), 3842 HadMultipleCandidates); 3843 return; 3844 } 3845 3846 // Add the user-defined conversion step that calls the conversion function. 3847 QualType ConvType = Function->getCallResultType(); 3848 if (ConvType->getAs<RecordType>()) { 3849 // If we're converting to a class type, there may be an copy of 3850 // the resulting temporary object (possible to create an object of 3851 // a base class type). That copy is not a separate conversion, so 3852 // we just make a note of the actual destination type (possibly a 3853 // base class of the type returned by the conversion function) and 3854 // let the user-defined conversion step handle the conversion. 3855 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType, 3856 HadMultipleCandidates); 3857 return; 3858 } 3859 3860 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType, 3861 HadMultipleCandidates); 3862 3863 // If the conversion following the call to the conversion function 3864 // is interesting, add it as a separate step. 3865 if (Best->FinalConversion.First || Best->FinalConversion.Second || 3866 Best->FinalConversion.Third) { 3867 ImplicitConversionSequence ICS; 3868 ICS.setStandard(); 3869 ICS.Standard = Best->FinalConversion; 3870 Sequence.AddConversionSequenceStep(ICS, DestType); 3871 } 3872 } 3873 3874 /// The non-zero enum values here are indexes into diagnostic alternatives. 3875 enum InvalidICRKind { IIK_okay, IIK_nonlocal, IIK_nonscalar }; 3876 3877 /// Determines whether this expression is an acceptable ICR source. 3878 static InvalidICRKind isInvalidICRSource(ASTContext &C, Expr *e, 3879 bool isAddressOf, bool &isWeakAccess) { 3880 // Skip parens. 3881 e = e->IgnoreParens(); 3882 3883 // Skip address-of nodes. 3884 if (UnaryOperator *op = dyn_cast<UnaryOperator>(e)) { 3885 if (op->getOpcode() == UO_AddrOf) 3886 return isInvalidICRSource(C, op->getSubExpr(), /*addressof*/ true, 3887 isWeakAccess); 3888 3889 // Skip certain casts. 3890 } else if (CastExpr *ce = dyn_cast<CastExpr>(e)) { 3891 switch (ce->getCastKind()) { 3892 case CK_Dependent: 3893 case CK_BitCast: 3894 case CK_LValueBitCast: 3895 case CK_NoOp: 3896 return isInvalidICRSource(C, ce->getSubExpr(), isAddressOf, isWeakAccess); 3897 3898 case CK_ArrayToPointerDecay: 3899 return IIK_nonscalar; 3900 3901 case CK_NullToPointer: 3902 return IIK_okay; 3903 3904 default: 3905 break; 3906 } 3907 3908 // If we have a declaration reference, it had better be a local variable. 3909 } else if (isa<DeclRefExpr>(e)) { 3910 // set isWeakAccess to true, to mean that there will be an implicit 3911 // load which requires a cleanup. 3912 if (e->getType().getObjCLifetime() == Qualifiers::OCL_Weak) 3913 isWeakAccess = true; 3914 3915 if (!isAddressOf) return IIK_nonlocal; 3916 3917 VarDecl *var = dyn_cast<VarDecl>(cast<DeclRefExpr>(e)->getDecl()); 3918 if (!var) return IIK_nonlocal; 3919 3920 return (var->hasLocalStorage() ? IIK_okay : IIK_nonlocal); 3921 3922 // If we have a conditional operator, check both sides. 3923 } else if (ConditionalOperator *cond = dyn_cast<ConditionalOperator>(e)) { 3924 if (InvalidICRKind iik = isInvalidICRSource(C, cond->getLHS(), isAddressOf, 3925 isWeakAccess)) 3926 return iik; 3927 3928 return isInvalidICRSource(C, cond->getRHS(), isAddressOf, isWeakAccess); 3929 3930 // These are never scalar. 3931 } else if (isa<ArraySubscriptExpr>(e)) { 3932 return IIK_nonscalar; 3933 3934 // Otherwise, it needs to be a null pointer constant. 3935 } else { 3936 return (e->isNullPointerConstant(C, Expr::NPC_ValueDependentIsNull) 3937 ? IIK_okay : IIK_nonlocal); 3938 } 3939 3940 return IIK_nonlocal; 3941 } 3942 3943 /// Check whether the given expression is a valid operand for an 3944 /// indirect copy/restore. 3945 static void checkIndirectCopyRestoreSource(Sema &S, Expr *src) { 3946 assert(src->isRValue()); 3947 bool isWeakAccess = false; 3948 InvalidICRKind iik = isInvalidICRSource(S.Context, src, false, isWeakAccess); 3949 // If isWeakAccess to true, there will be an implicit 3950 // load which requires a cleanup. 3951 if (S.getLangOpts().ObjCAutoRefCount && isWeakAccess) 3952 S.ExprNeedsCleanups = true; 3953 3954 if (iik == IIK_okay) return; 3955 3956 S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback) 3957 << ((unsigned) iik - 1) // shift index into diagnostic explanations 3958 << src->getSourceRange(); 3959 } 3960 3961 /// \brief Determine whether we have compatible array types for the 3962 /// purposes of GNU by-copy array initialization. 3963 static bool hasCompatibleArrayTypes(ASTContext &Context, 3964 const ArrayType *Dest, 3965 const ArrayType *Source) { 3966 // If the source and destination array types are equivalent, we're 3967 // done. 3968 if (Context.hasSameType(QualType(Dest, 0), QualType(Source, 0))) 3969 return true; 3970 3971 // Make sure that the element types are the same. 3972 if (!Context.hasSameType(Dest->getElementType(), Source->getElementType())) 3973 return false; 3974 3975 // The only mismatch we allow is when the destination is an 3976 // incomplete array type and the source is a constant array type. 3977 return Source->isConstantArrayType() && Dest->isIncompleteArrayType(); 3978 } 3979 3980 static bool tryObjCWritebackConversion(Sema &S, 3981 InitializationSequence &Sequence, 3982 const InitializedEntity &Entity, 3983 Expr *Initializer) { 3984 bool ArrayDecay = false; 3985 QualType ArgType = Initializer->getType(); 3986 QualType ArgPointee; 3987 if (const ArrayType *ArgArrayType = S.Context.getAsArrayType(ArgType)) { 3988 ArrayDecay = true; 3989 ArgPointee = ArgArrayType->getElementType(); 3990 ArgType = S.Context.getPointerType(ArgPointee); 3991 } 3992 3993 // Handle write-back conversion. 3994 QualType ConvertedArgType; 3995 if (!S.isObjCWritebackConversion(ArgType, Entity.getType(), 3996 ConvertedArgType)) 3997 return false; 3998 3999 // We should copy unless we're passing to an argument explicitly 4000 // marked 'out'. 4001 bool ShouldCopy = true; 4002 if (ParmVarDecl *param = cast_or_null<ParmVarDecl>(Entity.getDecl())) 4003 ShouldCopy = (param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out); 4004 4005 // Do we need an lvalue conversion? 4006 if (ArrayDecay || Initializer->isGLValue()) { 4007 ImplicitConversionSequence ICS; 4008 ICS.setStandard(); 4009 ICS.Standard.setAsIdentityConversion(); 4010 4011 QualType ResultType; 4012 if (ArrayDecay) { 4013 ICS.Standard.First = ICK_Array_To_Pointer; 4014 ResultType = S.Context.getPointerType(ArgPointee); 4015 } else { 4016 ICS.Standard.First = ICK_Lvalue_To_Rvalue; 4017 ResultType = Initializer->getType().getNonLValueExprType(S.Context); 4018 } 4019 4020 Sequence.AddConversionSequenceStep(ICS, ResultType); 4021 } 4022 4023 Sequence.AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy); 4024 return true; 4025 } 4026 4027 static bool TryOCLSamplerInitialization(Sema &S, 4028 InitializationSequence &Sequence, 4029 QualType DestType, 4030 Expr *Initializer) { 4031 if (!S.getLangOpts().OpenCL || !DestType->isSamplerT() || 4032 !Initializer->isIntegerConstantExpr(S.getASTContext())) 4033 return false; 4034 4035 Sequence.AddOCLSamplerInitStep(DestType); 4036 return true; 4037 } 4038 4039 // 4040 // OpenCL 1.2 spec, s6.12.10 4041 // 4042 // The event argument can also be used to associate the 4043 // async_work_group_copy with a previous async copy allowing 4044 // an event to be shared by multiple async copies; otherwise 4045 // event should be zero. 4046 // 4047 static bool TryOCLZeroEventInitialization(Sema &S, 4048 InitializationSequence &Sequence, 4049 QualType DestType, 4050 Expr *Initializer) { 4051 if (!S.getLangOpts().OpenCL || !DestType->isEventT() || 4052 !Initializer->isIntegerConstantExpr(S.getASTContext()) || 4053 (Initializer->EvaluateKnownConstInt(S.getASTContext()) != 0)) 4054 return false; 4055 4056 Sequence.AddOCLZeroEventStep(DestType); 4057 return true; 4058 } 4059 4060 InitializationSequence::InitializationSequence(Sema &S, 4061 const InitializedEntity &Entity, 4062 const InitializationKind &Kind, 4063 Expr **Args, 4064 unsigned NumArgs) 4065 : FailedCandidateSet(Kind.getLocation()) { 4066 ASTContext &Context = S.Context; 4067 4068 // C++0x [dcl.init]p16: 4069 // The semantics of initializers are as follows. The destination type is 4070 // the type of the object or reference being initialized and the source 4071 // type is the type of the initializer expression. The source type is not 4072 // defined when the initializer is a braced-init-list or when it is a 4073 // parenthesized list of expressions. 4074 QualType DestType = Entity.getType(); 4075 4076 if (DestType->isDependentType() || 4077 Expr::hasAnyTypeDependentArguments(llvm::makeArrayRef(Args, NumArgs))) { 4078 SequenceKind = DependentSequence; 4079 return; 4080 } 4081 4082 // Almost everything is a normal sequence. 4083 setSequenceKind(NormalSequence); 4084 4085 for (unsigned I = 0; I != NumArgs; ++I) 4086 if (Args[I]->getType()->isNonOverloadPlaceholderType()) { 4087 // FIXME: should we be doing this here? 4088 ExprResult result = S.CheckPlaceholderExpr(Args[I]); 4089 if (result.isInvalid()) { 4090 SetFailed(FK_PlaceholderType); 4091 return; 4092 } 4093 Args[I] = result.take(); 4094 } 4095 4096 4097 QualType SourceType; 4098 Expr *Initializer = 0; 4099 if (NumArgs == 1) { 4100 Initializer = Args[0]; 4101 if (!isa<InitListExpr>(Initializer)) 4102 SourceType = Initializer->getType(); 4103 } 4104 4105 // - If the initializer is a (non-parenthesized) braced-init-list, the 4106 // object is list-initialized (8.5.4). 4107 if (Kind.getKind() != InitializationKind::IK_Direct) { 4108 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) { 4109 TryListInitialization(S, Entity, Kind, InitList, *this); 4110 return; 4111 } 4112 } 4113 4114 // - If the destination type is a reference type, see 8.5.3. 4115 if (DestType->isReferenceType()) { 4116 // C++0x [dcl.init.ref]p1: 4117 // A variable declared to be a T& or T&&, that is, "reference to type T" 4118 // (8.3.2), shall be initialized by an object, or function, of type T or 4119 // by an object that can be converted into a T. 4120 // (Therefore, multiple arguments are not permitted.) 4121 if (NumArgs != 1) 4122 SetFailed(FK_TooManyInitsForReference); 4123 else 4124 TryReferenceInitialization(S, Entity, Kind, Args[0], *this); 4125 return; 4126 } 4127 4128 // - If the initializer is (), the object is value-initialized. 4129 if (Kind.getKind() == InitializationKind::IK_Value || 4130 (Kind.getKind() == InitializationKind::IK_Direct && NumArgs == 0)) { 4131 TryValueInitialization(S, Entity, Kind, *this); 4132 return; 4133 } 4134 4135 // Handle default initialization. 4136 if (Kind.getKind() == InitializationKind::IK_Default) { 4137 TryDefaultInitialization(S, Entity, Kind, *this); 4138 return; 4139 } 4140 4141 // - If the destination type is an array of characters, an array of 4142 // char16_t, an array of char32_t, or an array of wchar_t, and the 4143 // initializer is a string literal, see 8.5.2. 4144 // - Otherwise, if the destination type is an array, the program is 4145 // ill-formed. 4146 if (const ArrayType *DestAT = Context.getAsArrayType(DestType)) { 4147 if (Initializer && isa<VariableArrayType>(DestAT)) { 4148 SetFailed(FK_VariableLengthArrayHasInitializer); 4149 return; 4150 } 4151 4152 if (Initializer && IsStringInit(Initializer, DestAT, Context)) { 4153 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this); 4154 return; 4155 } 4156 4157 // Note: as an GNU C extension, we allow initialization of an 4158 // array from a compound literal that creates an array of the same 4159 // type, so long as the initializer has no side effects. 4160 if (!S.getLangOpts().CPlusPlus && Initializer && 4161 isa<CompoundLiteralExpr>(Initializer->IgnoreParens()) && 4162 Initializer->getType()->isArrayType()) { 4163 const ArrayType *SourceAT 4164 = Context.getAsArrayType(Initializer->getType()); 4165 if (!hasCompatibleArrayTypes(S.Context, DestAT, SourceAT)) 4166 SetFailed(FK_ArrayTypeMismatch); 4167 else if (Initializer->HasSideEffects(S.Context)) 4168 SetFailed(FK_NonConstantArrayInit); 4169 else { 4170 AddArrayInitStep(DestType); 4171 } 4172 } 4173 // Note: as a GNU C++ extension, we allow list-initialization of a 4174 // class member of array type from a parenthesized initializer list. 4175 else if (S.getLangOpts().CPlusPlus && 4176 Entity.getKind() == InitializedEntity::EK_Member && 4177 Initializer && isa<InitListExpr>(Initializer)) { 4178 TryListInitialization(S, Entity, Kind, cast<InitListExpr>(Initializer), 4179 *this); 4180 AddParenthesizedArrayInitStep(DestType); 4181 } else if (DestAT->getElementType()->isAnyCharacterType()) 4182 SetFailed(FK_ArrayNeedsInitListOrStringLiteral); 4183 else 4184 SetFailed(FK_ArrayNeedsInitList); 4185 4186 return; 4187 } 4188 4189 // Determine whether we should consider writeback conversions for 4190 // Objective-C ARC. 4191 bool allowObjCWritebackConversion = S.getLangOpts().ObjCAutoRefCount && 4192 Entity.getKind() == InitializedEntity::EK_Parameter; 4193 4194 // We're at the end of the line for C: it's either a write-back conversion 4195 // or it's a C assignment. There's no need to check anything else. 4196 if (!S.getLangOpts().CPlusPlus) { 4197 // If allowed, check whether this is an Objective-C writeback conversion. 4198 if (allowObjCWritebackConversion && 4199 tryObjCWritebackConversion(S, *this, Entity, Initializer)) { 4200 return; 4201 } 4202 4203 if (TryOCLSamplerInitialization(S, *this, DestType, Initializer)) 4204 return; 4205 4206 if (TryOCLZeroEventInitialization(S, *this, DestType, Initializer)) 4207 return; 4208 4209 // Handle initialization in C 4210 AddCAssignmentStep(DestType); 4211 MaybeProduceObjCObject(S, *this, Entity); 4212 return; 4213 } 4214 4215 assert(S.getLangOpts().CPlusPlus); 4216 4217 // - If the destination type is a (possibly cv-qualified) class type: 4218 if (DestType->isRecordType()) { 4219 // - If the initialization is direct-initialization, or if it is 4220 // copy-initialization where the cv-unqualified version of the 4221 // source type is the same class as, or a derived class of, the 4222 // class of the destination, constructors are considered. [...] 4223 if (Kind.getKind() == InitializationKind::IK_Direct || 4224 (Kind.getKind() == InitializationKind::IK_Copy && 4225 (Context.hasSameUnqualifiedType(SourceType, DestType) || 4226 S.IsDerivedFrom(SourceType, DestType)))) 4227 TryConstructorInitialization(S, Entity, Kind, Args, NumArgs, 4228 Entity.getType(), *this); 4229 // - Otherwise (i.e., for the remaining copy-initialization cases), 4230 // user-defined conversion sequences that can convert from the source 4231 // type to the destination type or (when a conversion function is 4232 // used) to a derived class thereof are enumerated as described in 4233 // 13.3.1.4, and the best one is chosen through overload resolution 4234 // (13.3). 4235 else 4236 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this); 4237 return; 4238 } 4239 4240 if (NumArgs > 1) { 4241 SetFailed(FK_TooManyInitsForScalar); 4242 return; 4243 } 4244 assert(NumArgs == 1 && "Zero-argument case handled above"); 4245 4246 // - Otherwise, if the source type is a (possibly cv-qualified) class 4247 // type, conversion functions are considered. 4248 if (!SourceType.isNull() && SourceType->isRecordType()) { 4249 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this); 4250 MaybeProduceObjCObject(S, *this, Entity); 4251 return; 4252 } 4253 4254 // - Otherwise, the initial value of the object being initialized is the 4255 // (possibly converted) value of the initializer expression. Standard 4256 // conversions (Clause 4) will be used, if necessary, to convert the 4257 // initializer expression to the cv-unqualified version of the 4258 // destination type; no user-defined conversions are considered. 4259 4260 ImplicitConversionSequence ICS 4261 = S.TryImplicitConversion(Initializer, Entity.getType(), 4262 /*SuppressUserConversions*/true, 4263 /*AllowExplicitConversions*/ false, 4264 /*InOverloadResolution*/ false, 4265 /*CStyle=*/Kind.isCStyleOrFunctionalCast(), 4266 allowObjCWritebackConversion); 4267 4268 if (ICS.isStandard() && 4269 ICS.Standard.Second == ICK_Writeback_Conversion) { 4270 // Objective-C ARC writeback conversion. 4271 4272 // We should copy unless we're passing to an argument explicitly 4273 // marked 'out'. 4274 bool ShouldCopy = true; 4275 if (ParmVarDecl *Param = cast_or_null<ParmVarDecl>(Entity.getDecl())) 4276 ShouldCopy = (Param->getObjCDeclQualifier() != ParmVarDecl::OBJC_TQ_Out); 4277 4278 // If there was an lvalue adjustment, add it as a separate conversion. 4279 if (ICS.Standard.First == ICK_Array_To_Pointer || 4280 ICS.Standard.First == ICK_Lvalue_To_Rvalue) { 4281 ImplicitConversionSequence LvalueICS; 4282 LvalueICS.setStandard(); 4283 LvalueICS.Standard.setAsIdentityConversion(); 4284 LvalueICS.Standard.setAllToTypes(ICS.Standard.getToType(0)); 4285 LvalueICS.Standard.First = ICS.Standard.First; 4286 AddConversionSequenceStep(LvalueICS, ICS.Standard.getToType(0)); 4287 } 4288 4289 AddPassByIndirectCopyRestoreStep(Entity.getType(), ShouldCopy); 4290 } else if (ICS.isBad()) { 4291 DeclAccessPair dap; 4292 if (Initializer->getType() == Context.OverloadTy && 4293 !S.ResolveAddressOfOverloadedFunction(Initializer 4294 , DestType, false, dap)) 4295 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 4296 else 4297 SetFailed(InitializationSequence::FK_ConversionFailed); 4298 } else { 4299 AddConversionSequenceStep(ICS, Entity.getType()); 4300 4301 MaybeProduceObjCObject(S, *this, Entity); 4302 } 4303 } 4304 4305 InitializationSequence::~InitializationSequence() { 4306 for (SmallVectorImpl<Step>::iterator Step = Steps.begin(), 4307 StepEnd = Steps.end(); 4308 Step != StepEnd; ++Step) 4309 Step->Destroy(); 4310 } 4311 4312 //===----------------------------------------------------------------------===// 4313 // Perform initialization 4314 //===----------------------------------------------------------------------===// 4315 static Sema::AssignmentAction 4316 getAssignmentAction(const InitializedEntity &Entity) { 4317 switch(Entity.getKind()) { 4318 case InitializedEntity::EK_Variable: 4319 case InitializedEntity::EK_New: 4320 case InitializedEntity::EK_Exception: 4321 case InitializedEntity::EK_Base: 4322 case InitializedEntity::EK_Delegating: 4323 return Sema::AA_Initializing; 4324 4325 case InitializedEntity::EK_Parameter: 4326 if (Entity.getDecl() && 4327 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext())) 4328 return Sema::AA_Sending; 4329 4330 return Sema::AA_Passing; 4331 4332 case InitializedEntity::EK_Result: 4333 return Sema::AA_Returning; 4334 4335 case InitializedEntity::EK_Temporary: 4336 // FIXME: Can we tell apart casting vs. converting? 4337 return Sema::AA_Casting; 4338 4339 case InitializedEntity::EK_Member: 4340 case InitializedEntity::EK_ArrayElement: 4341 case InitializedEntity::EK_VectorElement: 4342 case InitializedEntity::EK_ComplexElement: 4343 case InitializedEntity::EK_BlockElement: 4344 case InitializedEntity::EK_LambdaCapture: 4345 return Sema::AA_Initializing; 4346 } 4347 4348 llvm_unreachable("Invalid EntityKind!"); 4349 } 4350 4351 /// \brief Whether we should bind a created object as a temporary when 4352 /// initializing the given entity. 4353 static bool shouldBindAsTemporary(const InitializedEntity &Entity) { 4354 switch (Entity.getKind()) { 4355 case InitializedEntity::EK_ArrayElement: 4356 case InitializedEntity::EK_Member: 4357 case InitializedEntity::EK_Result: 4358 case InitializedEntity::EK_New: 4359 case InitializedEntity::EK_Variable: 4360 case InitializedEntity::EK_Base: 4361 case InitializedEntity::EK_Delegating: 4362 case InitializedEntity::EK_VectorElement: 4363 case InitializedEntity::EK_ComplexElement: 4364 case InitializedEntity::EK_Exception: 4365 case InitializedEntity::EK_BlockElement: 4366 case InitializedEntity::EK_LambdaCapture: 4367 return false; 4368 4369 case InitializedEntity::EK_Parameter: 4370 case InitializedEntity::EK_Temporary: 4371 return true; 4372 } 4373 4374 llvm_unreachable("missed an InitializedEntity kind?"); 4375 } 4376 4377 /// \brief Whether the given entity, when initialized with an object 4378 /// created for that initialization, requires destruction. 4379 static bool shouldDestroyTemporary(const InitializedEntity &Entity) { 4380 switch (Entity.getKind()) { 4381 case InitializedEntity::EK_Result: 4382 case InitializedEntity::EK_New: 4383 case InitializedEntity::EK_Base: 4384 case InitializedEntity::EK_Delegating: 4385 case InitializedEntity::EK_VectorElement: 4386 case InitializedEntity::EK_ComplexElement: 4387 case InitializedEntity::EK_BlockElement: 4388 case InitializedEntity::EK_LambdaCapture: 4389 return false; 4390 4391 case InitializedEntity::EK_Member: 4392 case InitializedEntity::EK_Variable: 4393 case InitializedEntity::EK_Parameter: 4394 case InitializedEntity::EK_Temporary: 4395 case InitializedEntity::EK_ArrayElement: 4396 case InitializedEntity::EK_Exception: 4397 return true; 4398 } 4399 4400 llvm_unreachable("missed an InitializedEntity kind?"); 4401 } 4402 4403 /// \brief Look for copy and move constructors and constructor templates, for 4404 /// copying an object via direct-initialization (per C++11 [dcl.init]p16). 4405 static void LookupCopyAndMoveConstructors(Sema &S, 4406 OverloadCandidateSet &CandidateSet, 4407 CXXRecordDecl *Class, 4408 Expr *CurInitExpr) { 4409 DeclContext::lookup_result R = S.LookupConstructors(Class); 4410 // The container holding the constructors can under certain conditions 4411 // be changed while iterating (e.g. because of deserialization). 4412 // To be safe we copy the lookup results to a new container. 4413 SmallVector<NamedDecl*, 16> Ctors(R.begin(), R.end()); 4414 for (SmallVector<NamedDecl*, 16>::iterator 4415 CI = Ctors.begin(), CE = Ctors.end(); CI != CE; ++CI) { 4416 NamedDecl *D = *CI; 4417 CXXConstructorDecl *Constructor = 0; 4418 4419 if ((Constructor = dyn_cast<CXXConstructorDecl>(D))) { 4420 // Handle copy/moveconstructors, only. 4421 if (!Constructor || Constructor->isInvalidDecl() || 4422 !Constructor->isCopyOrMoveConstructor() || 4423 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true)) 4424 continue; 4425 4426 DeclAccessPair FoundDecl 4427 = DeclAccessPair::make(Constructor, Constructor->getAccess()); 4428 S.AddOverloadCandidate(Constructor, FoundDecl, 4429 CurInitExpr, CandidateSet); 4430 continue; 4431 } 4432 4433 // Handle constructor templates. 4434 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(D); 4435 if (ConstructorTmpl->isInvalidDecl()) 4436 continue; 4437 4438 Constructor = cast<CXXConstructorDecl>( 4439 ConstructorTmpl->getTemplatedDecl()); 4440 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true)) 4441 continue; 4442 4443 // FIXME: Do we need to limit this to copy-constructor-like 4444 // candidates? 4445 DeclAccessPair FoundDecl 4446 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess()); 4447 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0, 4448 CurInitExpr, CandidateSet, true); 4449 } 4450 } 4451 4452 /// \brief Get the location at which initialization diagnostics should appear. 4453 static SourceLocation getInitializationLoc(const InitializedEntity &Entity, 4454 Expr *Initializer) { 4455 switch (Entity.getKind()) { 4456 case InitializedEntity::EK_Result: 4457 return Entity.getReturnLoc(); 4458 4459 case InitializedEntity::EK_Exception: 4460 return Entity.getThrowLoc(); 4461 4462 case InitializedEntity::EK_Variable: 4463 return Entity.getDecl()->getLocation(); 4464 4465 case InitializedEntity::EK_LambdaCapture: 4466 return Entity.getCaptureLoc(); 4467 4468 case InitializedEntity::EK_ArrayElement: 4469 case InitializedEntity::EK_Member: 4470 case InitializedEntity::EK_Parameter: 4471 case InitializedEntity::EK_Temporary: 4472 case InitializedEntity::EK_New: 4473 case InitializedEntity::EK_Base: 4474 case InitializedEntity::EK_Delegating: 4475 case InitializedEntity::EK_VectorElement: 4476 case InitializedEntity::EK_ComplexElement: 4477 case InitializedEntity::EK_BlockElement: 4478 return Initializer->getLocStart(); 4479 } 4480 llvm_unreachable("missed an InitializedEntity kind?"); 4481 } 4482 4483 /// \brief Make a (potentially elidable) temporary copy of the object 4484 /// provided by the given initializer by calling the appropriate copy 4485 /// constructor. 4486 /// 4487 /// \param S The Sema object used for type-checking. 4488 /// 4489 /// \param T The type of the temporary object, which must either be 4490 /// the type of the initializer expression or a superclass thereof. 4491 /// 4492 /// \param Entity The entity being initialized. 4493 /// 4494 /// \param CurInit The initializer expression. 4495 /// 4496 /// \param IsExtraneousCopy Whether this is an "extraneous" copy that 4497 /// is permitted in C++03 (but not C++0x) when binding a reference to 4498 /// an rvalue. 4499 /// 4500 /// \returns An expression that copies the initializer expression into 4501 /// a temporary object, or an error expression if a copy could not be 4502 /// created. 4503 static ExprResult CopyObject(Sema &S, 4504 QualType T, 4505 const InitializedEntity &Entity, 4506 ExprResult CurInit, 4507 bool IsExtraneousCopy) { 4508 // Determine which class type we're copying to. 4509 Expr *CurInitExpr = (Expr *)CurInit.get(); 4510 CXXRecordDecl *Class = 0; 4511 if (const RecordType *Record = T->getAs<RecordType>()) 4512 Class = cast<CXXRecordDecl>(Record->getDecl()); 4513 if (!Class) 4514 return CurInit; 4515 4516 // C++0x [class.copy]p32: 4517 // When certain criteria are met, an implementation is allowed to 4518 // omit the copy/move construction of a class object, even if the 4519 // copy/move constructor and/or destructor for the object have 4520 // side effects. [...] 4521 // - when a temporary class object that has not been bound to a 4522 // reference (12.2) would be copied/moved to a class object 4523 // with the same cv-unqualified type, the copy/move operation 4524 // can be omitted by constructing the temporary object 4525 // directly into the target of the omitted copy/move 4526 // 4527 // Note that the other three bullets are handled elsewhere. Copy 4528 // elision for return statements and throw expressions are handled as part 4529 // of constructor initialization, while copy elision for exception handlers 4530 // is handled by the run-time. 4531 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class); 4532 SourceLocation Loc = getInitializationLoc(Entity, CurInit.get()); 4533 4534 // Make sure that the type we are copying is complete. 4535 if (S.RequireCompleteType(Loc, T, diag::err_temp_copy_incomplete)) 4536 return CurInit; 4537 4538 // Perform overload resolution using the class's copy/move constructors. 4539 // Only consider constructors and constructor templates. Per 4540 // C++0x [dcl.init]p16, second bullet to class types, this initialization 4541 // is direct-initialization. 4542 OverloadCandidateSet CandidateSet(Loc); 4543 LookupCopyAndMoveConstructors(S, CandidateSet, Class, CurInitExpr); 4544 4545 bool HadMultipleCandidates = (CandidateSet.size() > 1); 4546 4547 OverloadCandidateSet::iterator Best; 4548 switch (CandidateSet.BestViableFunction(S, Loc, Best)) { 4549 case OR_Success: 4550 break; 4551 4552 case OR_No_Viable_Function: 4553 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext() 4554 ? diag::ext_rvalue_to_reference_temp_copy_no_viable 4555 : diag::err_temp_copy_no_viable) 4556 << (int)Entity.getKind() << CurInitExpr->getType() 4557 << CurInitExpr->getSourceRange(); 4558 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr); 4559 if (!IsExtraneousCopy || S.isSFINAEContext()) 4560 return ExprError(); 4561 return CurInit; 4562 4563 case OR_Ambiguous: 4564 S.Diag(Loc, diag::err_temp_copy_ambiguous) 4565 << (int)Entity.getKind() << CurInitExpr->getType() 4566 << CurInitExpr->getSourceRange(); 4567 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr); 4568 return ExprError(); 4569 4570 case OR_Deleted: 4571 S.Diag(Loc, diag::err_temp_copy_deleted) 4572 << (int)Entity.getKind() << CurInitExpr->getType() 4573 << CurInitExpr->getSourceRange(); 4574 S.NoteDeletedFunction(Best->Function); 4575 return ExprError(); 4576 } 4577 4578 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function); 4579 SmallVector<Expr*, 8> ConstructorArgs; 4580 CurInit.release(); // Ownership transferred into MultiExprArg, below. 4581 4582 S.CheckConstructorAccess(Loc, Constructor, Entity, 4583 Best->FoundDecl.getAccess(), IsExtraneousCopy); 4584 4585 if (IsExtraneousCopy) { 4586 // If this is a totally extraneous copy for C++03 reference 4587 // binding purposes, just return the original initialization 4588 // expression. We don't generate an (elided) copy operation here 4589 // because doing so would require us to pass down a flag to avoid 4590 // infinite recursion, where each step adds another extraneous, 4591 // elidable copy. 4592 4593 // Instantiate the default arguments of any extra parameters in 4594 // the selected copy constructor, as if we were going to create a 4595 // proper call to the copy constructor. 4596 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) { 4597 ParmVarDecl *Parm = Constructor->getParamDecl(I); 4598 if (S.RequireCompleteType(Loc, Parm->getType(), 4599 diag::err_call_incomplete_argument)) 4600 break; 4601 4602 // Build the default argument expression; we don't actually care 4603 // if this succeeds or not, because this routine will complain 4604 // if there was a problem. 4605 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm); 4606 } 4607 4608 return S.Owned(CurInitExpr); 4609 } 4610 4611 // Determine the arguments required to actually perform the 4612 // constructor call (we might have derived-to-base conversions, or 4613 // the copy constructor may have default arguments). 4614 if (S.CompleteConstructorCall(Constructor, MultiExprArg(&CurInitExpr, 1), 4615 Loc, ConstructorArgs)) 4616 return ExprError(); 4617 4618 // Actually perform the constructor call. 4619 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable, 4620 ConstructorArgs, 4621 HadMultipleCandidates, 4622 /*ListInit*/ false, 4623 /*ZeroInit*/ false, 4624 CXXConstructExpr::CK_Complete, 4625 SourceRange()); 4626 4627 // If we're supposed to bind temporaries, do so. 4628 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity)) 4629 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 4630 return CurInit; 4631 } 4632 4633 /// \brief Check whether elidable copy construction for binding a reference to 4634 /// a temporary would have succeeded if we were building in C++98 mode, for 4635 /// -Wc++98-compat. 4636 static void CheckCXX98CompatAccessibleCopy(Sema &S, 4637 const InitializedEntity &Entity, 4638 Expr *CurInitExpr) { 4639 assert(S.getLangOpts().CPlusPlus11); 4640 4641 const RecordType *Record = CurInitExpr->getType()->getAs<RecordType>(); 4642 if (!Record) 4643 return; 4644 4645 SourceLocation Loc = getInitializationLoc(Entity, CurInitExpr); 4646 if (S.Diags.getDiagnosticLevel(diag::warn_cxx98_compat_temp_copy, Loc) 4647 == DiagnosticsEngine::Ignored) 4648 return; 4649 4650 // Find constructors which would have been considered. 4651 OverloadCandidateSet CandidateSet(Loc); 4652 LookupCopyAndMoveConstructors( 4653 S, CandidateSet, cast<CXXRecordDecl>(Record->getDecl()), CurInitExpr); 4654 4655 // Perform overload resolution. 4656 OverloadCandidateSet::iterator Best; 4657 OverloadingResult OR = CandidateSet.BestViableFunction(S, Loc, Best); 4658 4659 PartialDiagnostic Diag = S.PDiag(diag::warn_cxx98_compat_temp_copy) 4660 << OR << (int)Entity.getKind() << CurInitExpr->getType() 4661 << CurInitExpr->getSourceRange(); 4662 4663 switch (OR) { 4664 case OR_Success: 4665 S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function), 4666 Entity, Best->FoundDecl.getAccess(), Diag); 4667 // FIXME: Check default arguments as far as that's possible. 4668 break; 4669 4670 case OR_No_Viable_Function: 4671 S.Diag(Loc, Diag); 4672 CandidateSet.NoteCandidates(S, OCD_AllCandidates, CurInitExpr); 4673 break; 4674 4675 case OR_Ambiguous: 4676 S.Diag(Loc, Diag); 4677 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, CurInitExpr); 4678 break; 4679 4680 case OR_Deleted: 4681 S.Diag(Loc, Diag); 4682 S.NoteDeletedFunction(Best->Function); 4683 break; 4684 } 4685 } 4686 4687 void InitializationSequence::PrintInitLocationNote(Sema &S, 4688 const InitializedEntity &Entity) { 4689 if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) { 4690 if (Entity.getDecl()->getLocation().isInvalid()) 4691 return; 4692 4693 if (Entity.getDecl()->getDeclName()) 4694 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here) 4695 << Entity.getDecl()->getDeclName(); 4696 else 4697 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here); 4698 } 4699 } 4700 4701 static bool isReferenceBinding(const InitializationSequence::Step &s) { 4702 return s.Kind == InitializationSequence::SK_BindReference || 4703 s.Kind == InitializationSequence::SK_BindReferenceToTemporary; 4704 } 4705 4706 static ExprResult 4707 PerformConstructorInitialization(Sema &S, 4708 const InitializedEntity &Entity, 4709 const InitializationKind &Kind, 4710 MultiExprArg Args, 4711 const InitializationSequence::Step& Step, 4712 bool &ConstructorInitRequiresZeroInit, 4713 bool IsListInitialization) { 4714 unsigned NumArgs = Args.size(); 4715 CXXConstructorDecl *Constructor 4716 = cast<CXXConstructorDecl>(Step.Function.Function); 4717 bool HadMultipleCandidates = Step.Function.HadMultipleCandidates; 4718 4719 // Build a call to the selected constructor. 4720 SmallVector<Expr*, 8> ConstructorArgs; 4721 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid()) 4722 ? Kind.getEqualLoc() 4723 : Kind.getLocation(); 4724 4725 if (Kind.getKind() == InitializationKind::IK_Default) { 4726 // Force even a trivial, implicit default constructor to be 4727 // semantically checked. We do this explicitly because we don't build 4728 // the definition for completely trivial constructors. 4729 assert(Constructor->getParent() && "No parent class for constructor."); 4730 if (Constructor->isDefaulted() && Constructor->isDefaultConstructor() && 4731 Constructor->isTrivial() && !Constructor->isUsed(false)) 4732 S.DefineImplicitDefaultConstructor(Loc, Constructor); 4733 } 4734 4735 ExprResult CurInit = S.Owned((Expr *)0); 4736 4737 // C++ [over.match.copy]p1: 4738 // - When initializing a temporary to be bound to the first parameter 4739 // of a constructor that takes a reference to possibly cv-qualified 4740 // T as its first argument, called with a single argument in the 4741 // context of direct-initialization, explicit conversion functions 4742 // are also considered. 4743 bool AllowExplicitConv = Kind.AllowExplicit() && !Kind.isCopyInit() && 4744 Args.size() == 1 && 4745 Constructor->isCopyOrMoveConstructor(); 4746 4747 // Determine the arguments required to actually perform the constructor 4748 // call. 4749 if (S.CompleteConstructorCall(Constructor, Args, 4750 Loc, ConstructorArgs, 4751 AllowExplicitConv, 4752 IsListInitialization)) 4753 return ExprError(); 4754 4755 4756 if (Entity.getKind() == InitializedEntity::EK_Temporary && 4757 (Kind.getKind() == InitializationKind::IK_DirectList || 4758 (NumArgs != 1 && // FIXME: Hack to work around cast weirdness 4759 (Kind.getKind() == InitializationKind::IK_Direct || 4760 Kind.getKind() == InitializationKind::IK_Value)))) { 4761 // An explicitly-constructed temporary, e.g., X(1, 2). 4762 S.MarkFunctionReferenced(Loc, Constructor); 4763 S.DiagnoseUseOfDecl(Constructor, Loc); 4764 4765 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo(); 4766 if (!TSInfo) 4767 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc); 4768 SourceRange ParenRange; 4769 if (Kind.getKind() != InitializationKind::IK_DirectList) 4770 ParenRange = Kind.getParenRange(); 4771 4772 CurInit = S.Owned( 4773 new (S.Context) CXXTemporaryObjectExpr(S.Context, Constructor, 4774 TSInfo, ConstructorArgs, 4775 ParenRange, IsListInitialization, 4776 HadMultipleCandidates, 4777 ConstructorInitRequiresZeroInit)); 4778 } else { 4779 CXXConstructExpr::ConstructionKind ConstructKind = 4780 CXXConstructExpr::CK_Complete; 4781 4782 if (Entity.getKind() == InitializedEntity::EK_Base) { 4783 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ? 4784 CXXConstructExpr::CK_VirtualBase : 4785 CXXConstructExpr::CK_NonVirtualBase; 4786 } else if (Entity.getKind() == InitializedEntity::EK_Delegating) { 4787 ConstructKind = CXXConstructExpr::CK_Delegating; 4788 } 4789 4790 // Only get the parenthesis range if it is a direct construction. 4791 SourceRange parenRange = 4792 Kind.getKind() == InitializationKind::IK_Direct ? 4793 Kind.getParenRange() : SourceRange(); 4794 4795 // If the entity allows NRVO, mark the construction as elidable 4796 // unconditionally. 4797 if (Entity.allowsNRVO()) 4798 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(), 4799 Constructor, /*Elidable=*/true, 4800 ConstructorArgs, 4801 HadMultipleCandidates, 4802 IsListInitialization, 4803 ConstructorInitRequiresZeroInit, 4804 ConstructKind, 4805 parenRange); 4806 else 4807 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(), 4808 Constructor, 4809 ConstructorArgs, 4810 HadMultipleCandidates, 4811 IsListInitialization, 4812 ConstructorInitRequiresZeroInit, 4813 ConstructKind, 4814 parenRange); 4815 } 4816 if (CurInit.isInvalid()) 4817 return ExprError(); 4818 4819 // Only check access if all of that succeeded. 4820 S.CheckConstructorAccess(Loc, Constructor, Entity, 4821 Step.Function.FoundDecl.getAccess()); 4822 S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc); 4823 4824 if (shouldBindAsTemporary(Entity)) 4825 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 4826 4827 return CurInit; 4828 } 4829 4830 /// Determine whether the specified InitializedEntity definitely has a lifetime 4831 /// longer than the current full-expression. Conservatively returns false if 4832 /// it's unclear. 4833 static bool 4834 InitializedEntityOutlivesFullExpression(const InitializedEntity &Entity) { 4835 const InitializedEntity *Top = &Entity; 4836 while (Top->getParent()) 4837 Top = Top->getParent(); 4838 4839 switch (Top->getKind()) { 4840 case InitializedEntity::EK_Variable: 4841 case InitializedEntity::EK_Result: 4842 case InitializedEntity::EK_Exception: 4843 case InitializedEntity::EK_Member: 4844 case InitializedEntity::EK_New: 4845 case InitializedEntity::EK_Base: 4846 case InitializedEntity::EK_Delegating: 4847 return true; 4848 4849 case InitializedEntity::EK_ArrayElement: 4850 case InitializedEntity::EK_VectorElement: 4851 case InitializedEntity::EK_BlockElement: 4852 case InitializedEntity::EK_ComplexElement: 4853 // Could not determine what the full initialization is. Assume it might not 4854 // outlive the full-expression. 4855 return false; 4856 4857 case InitializedEntity::EK_Parameter: 4858 case InitializedEntity::EK_Temporary: 4859 case InitializedEntity::EK_LambdaCapture: 4860 // The entity being initialized might not outlive the full-expression. 4861 return false; 4862 } 4863 4864 llvm_unreachable("unknown entity kind"); 4865 } 4866 4867 ExprResult 4868 InitializationSequence::Perform(Sema &S, 4869 const InitializedEntity &Entity, 4870 const InitializationKind &Kind, 4871 MultiExprArg Args, 4872 QualType *ResultType) { 4873 if (Failed()) { 4874 unsigned NumArgs = Args.size(); 4875 Diagnose(S, Entity, Kind, Args.data(), NumArgs); 4876 return ExprError(); 4877 } 4878 4879 if (getKind() == DependentSequence) { 4880 // If the declaration is a non-dependent, incomplete array type 4881 // that has an initializer, then its type will be completed once 4882 // the initializer is instantiated. 4883 if (ResultType && !Entity.getType()->isDependentType() && 4884 Args.size() == 1) { 4885 QualType DeclType = Entity.getType(); 4886 if (const IncompleteArrayType *ArrayT 4887 = S.Context.getAsIncompleteArrayType(DeclType)) { 4888 // FIXME: We don't currently have the ability to accurately 4889 // compute the length of an initializer list without 4890 // performing full type-checking of the initializer list 4891 // (since we have to determine where braces are implicitly 4892 // introduced and such). So, we fall back to making the array 4893 // type a dependently-sized array type with no specified 4894 // bound. 4895 if (isa<InitListExpr>((Expr *)Args[0])) { 4896 SourceRange Brackets; 4897 4898 // Scavange the location of the brackets from the entity, if we can. 4899 if (DeclaratorDecl *DD = Entity.getDecl()) { 4900 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) { 4901 TypeLoc TL = TInfo->getTypeLoc(); 4902 if (IncompleteArrayTypeLoc ArrayLoc = 4903 TL.getAs<IncompleteArrayTypeLoc>()) 4904 Brackets = ArrayLoc.getBracketsRange(); 4905 } 4906 } 4907 4908 *ResultType 4909 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(), 4910 /*NumElts=*/0, 4911 ArrayT->getSizeModifier(), 4912 ArrayT->getIndexTypeCVRQualifiers(), 4913 Brackets); 4914 } 4915 4916 } 4917 } 4918 if (Kind.getKind() == InitializationKind::IK_Direct && 4919 !Kind.isExplicitCast()) { 4920 // Rebuild the ParenListExpr. 4921 SourceRange ParenRange = Kind.getParenRange(); 4922 return S.ActOnParenListExpr(ParenRange.getBegin(), ParenRange.getEnd(), 4923 Args); 4924 } 4925 assert(Kind.getKind() == InitializationKind::IK_Copy || 4926 Kind.isExplicitCast() || 4927 Kind.getKind() == InitializationKind::IK_DirectList); 4928 return ExprResult(Args[0]); 4929 } 4930 4931 // No steps means no initialization. 4932 if (Steps.empty()) 4933 return S.Owned((Expr *)0); 4934 4935 if (S.getLangOpts().CPlusPlus11 && Entity.getType()->isReferenceType() && 4936 Args.size() == 1 && isa<InitListExpr>(Args[0]) && 4937 Entity.getKind() != InitializedEntity::EK_Parameter) { 4938 // Produce a C++98 compatibility warning if we are initializing a reference 4939 // from an initializer list. For parameters, we produce a better warning 4940 // elsewhere. 4941 Expr *Init = Args[0]; 4942 S.Diag(Init->getLocStart(), diag::warn_cxx98_compat_reference_list_init) 4943 << Init->getSourceRange(); 4944 } 4945 4946 // Diagnose cases where we initialize a pointer to an array temporary, and the 4947 // pointer obviously outlives the temporary. 4948 if (Args.size() == 1 && Args[0]->getType()->isArrayType() && 4949 Entity.getType()->isPointerType() && 4950 InitializedEntityOutlivesFullExpression(Entity)) { 4951 Expr *Init = Args[0]; 4952 Expr::LValueClassification Kind = Init->ClassifyLValue(S.Context); 4953 if (Kind == Expr::LV_ClassTemporary || Kind == Expr::LV_ArrayTemporary) 4954 S.Diag(Init->getLocStart(), diag::warn_temporary_array_to_pointer_decay) 4955 << Init->getSourceRange(); 4956 } 4957 4958 QualType DestType = Entity.getType().getNonReferenceType(); 4959 // FIXME: Ugly hack around the fact that Entity.getType() is not 4960 // the same as Entity.getDecl()->getType() in cases involving type merging, 4961 // and we want latter when it makes sense. 4962 if (ResultType) 4963 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() : 4964 Entity.getType(); 4965 4966 ExprResult CurInit = S.Owned((Expr *)0); 4967 4968 // For initialization steps that start with a single initializer, 4969 // grab the only argument out the Args and place it into the "current" 4970 // initializer. 4971 switch (Steps.front().Kind) { 4972 case SK_ResolveAddressOfOverloadedFunction: 4973 case SK_CastDerivedToBaseRValue: 4974 case SK_CastDerivedToBaseXValue: 4975 case SK_CastDerivedToBaseLValue: 4976 case SK_BindReference: 4977 case SK_BindReferenceToTemporary: 4978 case SK_ExtraneousCopyToTemporary: 4979 case SK_UserConversion: 4980 case SK_QualificationConversionLValue: 4981 case SK_QualificationConversionXValue: 4982 case SK_QualificationConversionRValue: 4983 case SK_ConversionSequence: 4984 case SK_ListInitialization: 4985 case SK_UnwrapInitList: 4986 case SK_RewrapInitList: 4987 case SK_CAssignment: 4988 case SK_StringInit: 4989 case SK_ObjCObjectConversion: 4990 case SK_ArrayInit: 4991 case SK_ParenthesizedArrayInit: 4992 case SK_PassByIndirectCopyRestore: 4993 case SK_PassByIndirectRestore: 4994 case SK_ProduceObjCObject: 4995 case SK_StdInitializerList: 4996 case SK_OCLSamplerInit: 4997 case SK_OCLZeroEvent: { 4998 assert(Args.size() == 1); 4999 CurInit = Args[0]; 5000 if (!CurInit.get()) return ExprError(); 5001 break; 5002 } 5003 5004 case SK_ConstructorInitialization: 5005 case SK_ListConstructorCall: 5006 case SK_ZeroInitialization: 5007 break; 5008 } 5009 5010 // Walk through the computed steps for the initialization sequence, 5011 // performing the specified conversions along the way. 5012 bool ConstructorInitRequiresZeroInit = false; 5013 for (step_iterator Step = step_begin(), StepEnd = step_end(); 5014 Step != StepEnd; ++Step) { 5015 if (CurInit.isInvalid()) 5016 return ExprError(); 5017 5018 QualType SourceType = CurInit.get() ? CurInit.get()->getType() : QualType(); 5019 5020 switch (Step->Kind) { 5021 case SK_ResolveAddressOfOverloadedFunction: 5022 // Overload resolution determined which function invoke; update the 5023 // initializer to reflect that choice. 5024 S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl); 5025 S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()); 5026 CurInit = S.FixOverloadedFunctionReference(CurInit, 5027 Step->Function.FoundDecl, 5028 Step->Function.Function); 5029 break; 5030 5031 case SK_CastDerivedToBaseRValue: 5032 case SK_CastDerivedToBaseXValue: 5033 case SK_CastDerivedToBaseLValue: { 5034 // We have a derived-to-base cast that produces either an rvalue or an 5035 // lvalue. Perform that cast. 5036 5037 CXXCastPath BasePath; 5038 5039 // Casts to inaccessible base classes are allowed with C-style casts. 5040 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast(); 5041 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type, 5042 CurInit.get()->getLocStart(), 5043 CurInit.get()->getSourceRange(), 5044 &BasePath, IgnoreBaseAccess)) 5045 return ExprError(); 5046 5047 if (S.BasePathInvolvesVirtualBase(BasePath)) { 5048 QualType T = SourceType; 5049 if (const PointerType *Pointer = T->getAs<PointerType>()) 5050 T = Pointer->getPointeeType(); 5051 if (const RecordType *RecordTy = T->getAs<RecordType>()) 5052 S.MarkVTableUsed(CurInit.get()->getLocStart(), 5053 cast<CXXRecordDecl>(RecordTy->getDecl())); 5054 } 5055 5056 ExprValueKind VK = 5057 Step->Kind == SK_CastDerivedToBaseLValue ? 5058 VK_LValue : 5059 (Step->Kind == SK_CastDerivedToBaseXValue ? 5060 VK_XValue : 5061 VK_RValue); 5062 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, 5063 Step->Type, 5064 CK_DerivedToBase, 5065 CurInit.get(), 5066 &BasePath, VK)); 5067 break; 5068 } 5069 5070 case SK_BindReference: 5071 if (FieldDecl *BitField = CurInit.get()->getBitField()) { 5072 // References cannot bind to bit fields (C++ [dcl.init.ref]p5). 5073 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield) 5074 << Entity.getType().isVolatileQualified() 5075 << BitField->getDeclName() 5076 << CurInit.get()->getSourceRange(); 5077 S.Diag(BitField->getLocation(), diag::note_bitfield_decl); 5078 return ExprError(); 5079 } 5080 5081 if (CurInit.get()->refersToVectorElement()) { 5082 // References cannot bind to vector elements. 5083 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element) 5084 << Entity.getType().isVolatileQualified() 5085 << CurInit.get()->getSourceRange(); 5086 PrintInitLocationNote(S, Entity); 5087 return ExprError(); 5088 } 5089 5090 // Reference binding does not have any corresponding ASTs. 5091 5092 // Check exception specifications 5093 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType)) 5094 return ExprError(); 5095 5096 break; 5097 5098 case SK_BindReferenceToTemporary: 5099 // Check exception specifications 5100 if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType)) 5101 return ExprError(); 5102 5103 // Materialize the temporary into memory. 5104 CurInit = new (S.Context) MaterializeTemporaryExpr( 5105 Entity.getType().getNonReferenceType(), 5106 CurInit.get(), 5107 Entity.getType()->isLValueReferenceType()); 5108 5109 // If we're binding to an Objective-C object that has lifetime, we 5110 // need cleanups. 5111 if (S.getLangOpts().ObjCAutoRefCount && 5112 CurInit.get()->getType()->isObjCLifetimeType()) 5113 S.ExprNeedsCleanups = true; 5114 5115 break; 5116 5117 case SK_ExtraneousCopyToTemporary: 5118 CurInit = CopyObject(S, Step->Type, Entity, CurInit, 5119 /*IsExtraneousCopy=*/true); 5120 break; 5121 5122 case SK_UserConversion: { 5123 // We have a user-defined conversion that invokes either a constructor 5124 // or a conversion function. 5125 CastKind CastKind; 5126 bool IsCopy = false; 5127 FunctionDecl *Fn = Step->Function.Function; 5128 DeclAccessPair FoundFn = Step->Function.FoundDecl; 5129 bool HadMultipleCandidates = Step->Function.HadMultipleCandidates; 5130 bool CreatedObject = false; 5131 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) { 5132 // Build a call to the selected constructor. 5133 SmallVector<Expr*, 8> ConstructorArgs; 5134 SourceLocation Loc = CurInit.get()->getLocStart(); 5135 CurInit.release(); // Ownership transferred into MultiExprArg, below. 5136 5137 // Determine the arguments required to actually perform the constructor 5138 // call. 5139 Expr *Arg = CurInit.get(); 5140 if (S.CompleteConstructorCall(Constructor, 5141 MultiExprArg(&Arg, 1), 5142 Loc, ConstructorArgs)) 5143 return ExprError(); 5144 5145 // Build an expression that constructs a temporary. 5146 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor, 5147 ConstructorArgs, 5148 HadMultipleCandidates, 5149 /*ListInit*/ false, 5150 /*ZeroInit*/ false, 5151 CXXConstructExpr::CK_Complete, 5152 SourceRange()); 5153 if (CurInit.isInvalid()) 5154 return ExprError(); 5155 5156 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity, 5157 FoundFn.getAccess()); 5158 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()); 5159 5160 CastKind = CK_ConstructorConversion; 5161 QualType Class = S.Context.getTypeDeclType(Constructor->getParent()); 5162 if (S.Context.hasSameUnqualifiedType(SourceType, Class) || 5163 S.IsDerivedFrom(SourceType, Class)) 5164 IsCopy = true; 5165 5166 CreatedObject = true; 5167 } else { 5168 // Build a call to the conversion function. 5169 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn); 5170 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), 0, 5171 FoundFn); 5172 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()); 5173 5174 // FIXME: Should we move this initialization into a separate 5175 // derived-to-base conversion? I believe the answer is "no", because 5176 // we don't want to turn off access control here for c-style casts. 5177 ExprResult CurInitExprRes = 5178 S.PerformObjectArgumentInitialization(CurInit.take(), /*Qualifier=*/0, 5179 FoundFn, Conversion); 5180 if(CurInitExprRes.isInvalid()) 5181 return ExprError(); 5182 CurInit = CurInitExprRes; 5183 5184 // Build the actual call to the conversion function. 5185 CurInit = S.BuildCXXMemberCallExpr(CurInit.get(), FoundFn, Conversion, 5186 HadMultipleCandidates); 5187 if (CurInit.isInvalid() || !CurInit.get()) 5188 return ExprError(); 5189 5190 CastKind = CK_UserDefinedConversion; 5191 5192 CreatedObject = Conversion->getResultType()->isRecordType(); 5193 } 5194 5195 bool RequiresCopy = !IsCopy && !isReferenceBinding(Steps.back()); 5196 bool MaybeBindToTemp = RequiresCopy || shouldBindAsTemporary(Entity); 5197 5198 if (!MaybeBindToTemp && CreatedObject && shouldDestroyTemporary(Entity)) { 5199 QualType T = CurInit.get()->getType(); 5200 if (const RecordType *Record = T->getAs<RecordType>()) { 5201 CXXDestructorDecl *Destructor 5202 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl())); 5203 S.CheckDestructorAccess(CurInit.get()->getLocStart(), Destructor, 5204 S.PDiag(diag::err_access_dtor_temp) << T); 5205 S.MarkFunctionReferenced(CurInit.get()->getLocStart(), Destructor); 5206 S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getLocStart()); 5207 } 5208 } 5209 5210 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, 5211 CurInit.get()->getType(), 5212 CastKind, CurInit.get(), 0, 5213 CurInit.get()->getValueKind())); 5214 if (MaybeBindToTemp) 5215 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 5216 if (RequiresCopy) 5217 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity, 5218 CurInit, /*IsExtraneousCopy=*/false); 5219 break; 5220 } 5221 5222 case SK_QualificationConversionLValue: 5223 case SK_QualificationConversionXValue: 5224 case SK_QualificationConversionRValue: { 5225 // Perform a qualification conversion; these can never go wrong. 5226 ExprValueKind VK = 5227 Step->Kind == SK_QualificationConversionLValue ? 5228 VK_LValue : 5229 (Step->Kind == SK_QualificationConversionXValue ? 5230 VK_XValue : 5231 VK_RValue); 5232 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, CK_NoOp, VK); 5233 break; 5234 } 5235 5236 case SK_ConversionSequence: { 5237 Sema::CheckedConversionKind CCK 5238 = Kind.isCStyleCast()? Sema::CCK_CStyleCast 5239 : Kind.isFunctionalCast()? Sema::CCK_FunctionalCast 5240 : Kind.isExplicitCast()? Sema::CCK_OtherCast 5241 : Sema::CCK_ImplicitConversion; 5242 ExprResult CurInitExprRes = 5243 S.PerformImplicitConversion(CurInit.get(), Step->Type, *Step->ICS, 5244 getAssignmentAction(Entity), CCK); 5245 if (CurInitExprRes.isInvalid()) 5246 return ExprError(); 5247 CurInit = CurInitExprRes; 5248 break; 5249 } 5250 5251 case SK_ListInitialization: { 5252 InitListExpr *InitList = cast<InitListExpr>(CurInit.get()); 5253 // Hack: We must pass *ResultType if available in order to set the type 5254 // of arrays, e.g. in 'int ar[] = {1, 2, 3};'. 5255 // But in 'const X &x = {1, 2, 3};' we're supposed to initialize a 5256 // temporary, not a reference, so we should pass Ty. 5257 // Worst case: 'const int (&arref)[] = {1, 2, 3};'. 5258 // Since this step is never used for a reference directly, we explicitly 5259 // unwrap references here and rewrap them afterwards. 5260 // We also need to create a InitializeTemporary entity for this. 5261 QualType Ty = ResultType ? ResultType->getNonReferenceType() : Step->Type; 5262 bool IsTemporary = Entity.getType()->isReferenceType(); 5263 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(Ty); 5264 InitializedEntity InitEntity = IsTemporary ? TempEntity : Entity; 5265 InitListChecker PerformInitList(S, InitEntity, 5266 InitList, Ty, /*VerifyOnly=*/false, 5267 Kind.getKind() != InitializationKind::IK_DirectList || 5268 !S.getLangOpts().CPlusPlus11); 5269 if (PerformInitList.HadError()) 5270 return ExprError(); 5271 5272 if (ResultType) { 5273 if ((*ResultType)->isRValueReferenceType()) 5274 Ty = S.Context.getRValueReferenceType(Ty); 5275 else if ((*ResultType)->isLValueReferenceType()) 5276 Ty = S.Context.getLValueReferenceType(Ty, 5277 (*ResultType)->getAs<LValueReferenceType>()->isSpelledAsLValue()); 5278 *ResultType = Ty; 5279 } 5280 5281 InitListExpr *StructuredInitList = 5282 PerformInitList.getFullyStructuredList(); 5283 CurInit.release(); 5284 CurInit = shouldBindAsTemporary(InitEntity) 5285 ? S.MaybeBindToTemporary(StructuredInitList) 5286 : S.Owned(StructuredInitList); 5287 break; 5288 } 5289 5290 case SK_ListConstructorCall: { 5291 // When an initializer list is passed for a parameter of type "reference 5292 // to object", we don't get an EK_Temporary entity, but instead an 5293 // EK_Parameter entity with reference type. 5294 // FIXME: This is a hack. What we really should do is create a user 5295 // conversion step for this case, but this makes it considerably more 5296 // complicated. For now, this will do. 5297 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary( 5298 Entity.getType().getNonReferenceType()); 5299 bool UseTemporary = Entity.getType()->isReferenceType(); 5300 assert(Args.size() == 1 && "expected a single argument for list init"); 5301 InitListExpr *InitList = cast<InitListExpr>(Args[0]); 5302 S.Diag(InitList->getExprLoc(), diag::warn_cxx98_compat_ctor_list_init) 5303 << InitList->getSourceRange(); 5304 MultiExprArg Arg(InitList->getInits(), InitList->getNumInits()); 5305 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity : 5306 Entity, 5307 Kind, Arg, *Step, 5308 ConstructorInitRequiresZeroInit, 5309 /*IsListInitialization*/ true); 5310 break; 5311 } 5312 5313 case SK_UnwrapInitList: 5314 CurInit = S.Owned(cast<InitListExpr>(CurInit.take())->getInit(0)); 5315 break; 5316 5317 case SK_RewrapInitList: { 5318 Expr *E = CurInit.take(); 5319 InitListExpr *Syntactic = Step->WrappingSyntacticList; 5320 InitListExpr *ILE = new (S.Context) InitListExpr(S.Context, 5321 Syntactic->getLBraceLoc(), E, Syntactic->getRBraceLoc()); 5322 ILE->setSyntacticForm(Syntactic); 5323 ILE->setType(E->getType()); 5324 ILE->setValueKind(E->getValueKind()); 5325 CurInit = S.Owned(ILE); 5326 break; 5327 } 5328 5329 case SK_ConstructorInitialization: { 5330 // When an initializer list is passed for a parameter of type "reference 5331 // to object", we don't get an EK_Temporary entity, but instead an 5332 // EK_Parameter entity with reference type. 5333 // FIXME: This is a hack. What we really should do is create a user 5334 // conversion step for this case, but this makes it considerably more 5335 // complicated. For now, this will do. 5336 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary( 5337 Entity.getType().getNonReferenceType()); 5338 bool UseTemporary = Entity.getType()->isReferenceType(); 5339 CurInit = PerformConstructorInitialization(S, UseTemporary ? TempEntity 5340 : Entity, 5341 Kind, Args, *Step, 5342 ConstructorInitRequiresZeroInit, 5343 /*IsListInitialization*/ false); 5344 break; 5345 } 5346 5347 case SK_ZeroInitialization: { 5348 step_iterator NextStep = Step; 5349 ++NextStep; 5350 if (NextStep != StepEnd && 5351 (NextStep->Kind == SK_ConstructorInitialization || 5352 NextStep->Kind == SK_ListConstructorCall)) { 5353 // The need for zero-initialization is recorded directly into 5354 // the call to the object's constructor within the next step. 5355 ConstructorInitRequiresZeroInit = true; 5356 } else if (Kind.getKind() == InitializationKind::IK_Value && 5357 S.getLangOpts().CPlusPlus && 5358 !Kind.isImplicitValueInit()) { 5359 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo(); 5360 if (!TSInfo) 5361 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type, 5362 Kind.getRange().getBegin()); 5363 5364 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr( 5365 TSInfo->getType().getNonLValueExprType(S.Context), 5366 TSInfo, 5367 Kind.getRange().getEnd())); 5368 } else { 5369 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type)); 5370 } 5371 break; 5372 } 5373 5374 case SK_CAssignment: { 5375 QualType SourceType = CurInit.get()->getType(); 5376 ExprResult Result = CurInit; 5377 Sema::AssignConvertType ConvTy = 5378 S.CheckSingleAssignmentConstraints(Step->Type, Result); 5379 if (Result.isInvalid()) 5380 return ExprError(); 5381 CurInit = Result; 5382 5383 // If this is a call, allow conversion to a transparent union. 5384 ExprResult CurInitExprRes = CurInit; 5385 if (ConvTy != Sema::Compatible && 5386 Entity.getKind() == InitializedEntity::EK_Parameter && 5387 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExprRes) 5388 == Sema::Compatible) 5389 ConvTy = Sema::Compatible; 5390 if (CurInitExprRes.isInvalid()) 5391 return ExprError(); 5392 CurInit = CurInitExprRes; 5393 5394 bool Complained; 5395 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(), 5396 Step->Type, SourceType, 5397 CurInit.get(), 5398 getAssignmentAction(Entity), 5399 &Complained)) { 5400 PrintInitLocationNote(S, Entity); 5401 return ExprError(); 5402 } else if (Complained) 5403 PrintInitLocationNote(S, Entity); 5404 break; 5405 } 5406 5407 case SK_StringInit: { 5408 QualType Ty = Step->Type; 5409 CheckStringInit(CurInit.get(), ResultType ? *ResultType : Ty, 5410 S.Context.getAsArrayType(Ty), S); 5411 break; 5412 } 5413 5414 case SK_ObjCObjectConversion: 5415 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, 5416 CK_ObjCObjectLValueCast, 5417 CurInit.get()->getValueKind()); 5418 break; 5419 5420 case SK_ArrayInit: 5421 // Okay: we checked everything before creating this step. Note that 5422 // this is a GNU extension. 5423 S.Diag(Kind.getLocation(), diag::ext_array_init_copy) 5424 << Step->Type << CurInit.get()->getType() 5425 << CurInit.get()->getSourceRange(); 5426 5427 // If the destination type is an incomplete array type, update the 5428 // type accordingly. 5429 if (ResultType) { 5430 if (const IncompleteArrayType *IncompleteDest 5431 = S.Context.getAsIncompleteArrayType(Step->Type)) { 5432 if (const ConstantArrayType *ConstantSource 5433 = S.Context.getAsConstantArrayType(CurInit.get()->getType())) { 5434 *ResultType = S.Context.getConstantArrayType( 5435 IncompleteDest->getElementType(), 5436 ConstantSource->getSize(), 5437 ArrayType::Normal, 0); 5438 } 5439 } 5440 } 5441 break; 5442 5443 case SK_ParenthesizedArrayInit: 5444 // Okay: we checked everything before creating this step. Note that 5445 // this is a GNU extension. 5446 S.Diag(Kind.getLocation(), diag::ext_array_init_parens) 5447 << CurInit.get()->getSourceRange(); 5448 break; 5449 5450 case SK_PassByIndirectCopyRestore: 5451 case SK_PassByIndirectRestore: 5452 checkIndirectCopyRestoreSource(S, CurInit.get()); 5453 CurInit = S.Owned(new (S.Context) 5454 ObjCIndirectCopyRestoreExpr(CurInit.take(), Step->Type, 5455 Step->Kind == SK_PassByIndirectCopyRestore)); 5456 break; 5457 5458 case SK_ProduceObjCObject: 5459 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, Step->Type, 5460 CK_ARCProduceObject, 5461 CurInit.take(), 0, VK_RValue)); 5462 break; 5463 5464 case SK_StdInitializerList: { 5465 QualType Dest = Step->Type; 5466 QualType E; 5467 bool Success = S.isStdInitializerList(Dest, &E); 5468 (void)Success; 5469 assert(Success && "Destination type changed?"); 5470 5471 // If the element type has a destructor, check it. 5472 if (CXXRecordDecl *RD = E->getAsCXXRecordDecl()) { 5473 if (!RD->hasIrrelevantDestructor()) { 5474 if (CXXDestructorDecl *Destructor = S.LookupDestructor(RD)) { 5475 S.MarkFunctionReferenced(Kind.getLocation(), Destructor); 5476 S.CheckDestructorAccess(Kind.getLocation(), Destructor, 5477 S.PDiag(diag::err_access_dtor_temp) << E); 5478 S.DiagnoseUseOfDecl(Destructor, Kind.getLocation()); 5479 } 5480 } 5481 } 5482 5483 InitListExpr *ILE = cast<InitListExpr>(CurInit.take()); 5484 S.Diag(ILE->getExprLoc(), diag::warn_cxx98_compat_initializer_list_init) 5485 << ILE->getSourceRange(); 5486 unsigned NumInits = ILE->getNumInits(); 5487 SmallVector<Expr*, 16> Converted(NumInits); 5488 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary( 5489 S.Context.getConstantArrayType(E, 5490 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()), 5491 NumInits), 5492 ArrayType::Normal, 0)); 5493 InitializedEntity Element =InitializedEntity::InitializeElement(S.Context, 5494 0, HiddenArray); 5495 for (unsigned i = 0; i < NumInits; ++i) { 5496 Element.setElementIndex(i); 5497 ExprResult Init = S.Owned(ILE->getInit(i)); 5498 ExprResult Res = S.PerformCopyInitialization( 5499 Element, Init.get()->getExprLoc(), Init, 5500 /*TopLevelOfInitList=*/ true); 5501 assert(!Res.isInvalid() && "Result changed since try phase."); 5502 Converted[i] = Res.take(); 5503 } 5504 InitListExpr *Semantic = new (S.Context) 5505 InitListExpr(S.Context, ILE->getLBraceLoc(), 5506 Converted, ILE->getRBraceLoc()); 5507 Semantic->setSyntacticForm(ILE); 5508 Semantic->setType(Dest); 5509 Semantic->setInitializesStdInitializerList(); 5510 CurInit = S.Owned(Semantic); 5511 break; 5512 } 5513 case SK_OCLSamplerInit: { 5514 assert(Step->Type->isSamplerT() && 5515 "Sampler initialization on non sampler type."); 5516 5517 QualType SourceType = CurInit.get()->getType(); 5518 InitializedEntity::EntityKind EntityKind = Entity.getKind(); 5519 5520 if (EntityKind == InitializedEntity::EK_Parameter) { 5521 if (!SourceType->isSamplerT()) 5522 S.Diag(Kind.getLocation(), diag::err_sampler_argument_required) 5523 << SourceType; 5524 } else if (EntityKind != InitializedEntity::EK_Variable) { 5525 llvm_unreachable("Invalid EntityKind!"); 5526 } 5527 5528 break; 5529 } 5530 case SK_OCLZeroEvent: { 5531 assert(Step->Type->isEventT() && 5532 "Event initialization on non event type."); 5533 5534 CurInit = S.ImpCastExprToType(CurInit.take(), Step->Type, 5535 CK_ZeroToOCLEvent, 5536 CurInit.get()->getValueKind()); 5537 break; 5538 } 5539 } 5540 } 5541 5542 // Diagnose non-fatal problems with the completed initialization. 5543 if (Entity.getKind() == InitializedEntity::EK_Member && 5544 cast<FieldDecl>(Entity.getDecl())->isBitField()) 5545 S.CheckBitFieldInitialization(Kind.getLocation(), 5546 cast<FieldDecl>(Entity.getDecl()), 5547 CurInit.get()); 5548 5549 return CurInit; 5550 } 5551 5552 /// Somewhere within T there is an uninitialized reference subobject. 5553 /// Dig it out and diagnose it. 5554 static bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, 5555 QualType T) { 5556 if (T->isReferenceType()) { 5557 S.Diag(Loc, diag::err_reference_without_init) 5558 << T.getNonReferenceType(); 5559 return true; 5560 } 5561 5562 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl(); 5563 if (!RD || !RD->hasUninitializedReferenceMember()) 5564 return false; 5565 5566 for (CXXRecordDecl::field_iterator FI = RD->field_begin(), 5567 FE = RD->field_end(); FI != FE; ++FI) { 5568 if (FI->isUnnamedBitfield()) 5569 continue; 5570 5571 if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) { 5572 S.Diag(Loc, diag::note_value_initialization_here) << RD; 5573 return true; 5574 } 5575 } 5576 5577 for (CXXRecordDecl::base_class_iterator BI = RD->bases_begin(), 5578 BE = RD->bases_end(); 5579 BI != BE; ++BI) { 5580 if (DiagnoseUninitializedReference(S, BI->getLocStart(), BI->getType())) { 5581 S.Diag(Loc, diag::note_value_initialization_here) << RD; 5582 return true; 5583 } 5584 } 5585 5586 return false; 5587 } 5588 5589 5590 //===----------------------------------------------------------------------===// 5591 // Diagnose initialization failures 5592 //===----------------------------------------------------------------------===// 5593 bool InitializationSequence::Diagnose(Sema &S, 5594 const InitializedEntity &Entity, 5595 const InitializationKind &Kind, 5596 Expr **Args, unsigned NumArgs) { 5597 if (!Failed()) 5598 return false; 5599 5600 QualType DestType = Entity.getType(); 5601 switch (Failure) { 5602 case FK_TooManyInitsForReference: 5603 // FIXME: Customize for the initialized entity? 5604 if (NumArgs == 0) { 5605 // Dig out the reference subobject which is uninitialized and diagnose it. 5606 // If this is value-initialization, this could be nested some way within 5607 // the target type. 5608 assert(Kind.getKind() == InitializationKind::IK_Value || 5609 DestType->isReferenceType()); 5610 bool Diagnosed = 5611 DiagnoseUninitializedReference(S, Kind.getLocation(), DestType); 5612 assert(Diagnosed && "couldn't find uninitialized reference to diagnose"); 5613 (void)Diagnosed; 5614 } else // FIXME: diagnostic below could be better! 5615 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits) 5616 << SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd()); 5617 break; 5618 5619 case FK_ArrayNeedsInitList: 5620 case FK_ArrayNeedsInitListOrStringLiteral: 5621 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) 5622 << (Failure == FK_ArrayNeedsInitListOrStringLiteral); 5623 break; 5624 5625 case FK_ArrayTypeMismatch: 5626 case FK_NonConstantArrayInit: 5627 S.Diag(Kind.getLocation(), 5628 (Failure == FK_ArrayTypeMismatch 5629 ? diag::err_array_init_different_type 5630 : diag::err_array_init_non_constant_array)) 5631 << DestType.getNonReferenceType() 5632 << Args[0]->getType() 5633 << Args[0]->getSourceRange(); 5634 break; 5635 5636 case FK_VariableLengthArrayHasInitializer: 5637 S.Diag(Kind.getLocation(), diag::err_variable_object_no_init) 5638 << Args[0]->getSourceRange(); 5639 break; 5640 5641 case FK_AddressOfOverloadFailed: { 5642 DeclAccessPair Found; 5643 S.ResolveAddressOfOverloadedFunction(Args[0], 5644 DestType.getNonReferenceType(), 5645 true, 5646 Found); 5647 break; 5648 } 5649 5650 case FK_ReferenceInitOverloadFailed: 5651 case FK_UserConversionOverloadFailed: 5652 switch (FailedOverloadResult) { 5653 case OR_Ambiguous: 5654 if (Failure == FK_UserConversionOverloadFailed) 5655 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition) 5656 << Args[0]->getType() << DestType 5657 << Args[0]->getSourceRange(); 5658 else 5659 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous) 5660 << DestType << Args[0]->getType() 5661 << Args[0]->getSourceRange(); 5662 5663 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, 5664 llvm::makeArrayRef(Args, NumArgs)); 5665 break; 5666 5667 case OR_No_Viable_Function: 5668 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition) 5669 << Args[0]->getType() << DestType.getNonReferenceType() 5670 << Args[0]->getSourceRange(); 5671 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, 5672 llvm::makeArrayRef(Args, NumArgs)); 5673 break; 5674 5675 case OR_Deleted: { 5676 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function) 5677 << Args[0]->getType() << DestType.getNonReferenceType() 5678 << Args[0]->getSourceRange(); 5679 OverloadCandidateSet::iterator Best; 5680 OverloadingResult Ovl 5681 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best, 5682 true); 5683 if (Ovl == OR_Deleted) { 5684 S.NoteDeletedFunction(Best->Function); 5685 } else { 5686 llvm_unreachable("Inconsistent overload resolution?"); 5687 } 5688 break; 5689 } 5690 5691 case OR_Success: 5692 llvm_unreachable("Conversion did not fail!"); 5693 } 5694 break; 5695 5696 case FK_NonConstLValueReferenceBindingToTemporary: 5697 if (isa<InitListExpr>(Args[0])) { 5698 S.Diag(Kind.getLocation(), 5699 diag::err_lvalue_reference_bind_to_initlist) 5700 << DestType.getNonReferenceType().isVolatileQualified() 5701 << DestType.getNonReferenceType() 5702 << Args[0]->getSourceRange(); 5703 break; 5704 } 5705 // Intentional fallthrough 5706 5707 case FK_NonConstLValueReferenceBindingToUnrelated: 5708 S.Diag(Kind.getLocation(), 5709 Failure == FK_NonConstLValueReferenceBindingToTemporary 5710 ? diag::err_lvalue_reference_bind_to_temporary 5711 : diag::err_lvalue_reference_bind_to_unrelated) 5712 << DestType.getNonReferenceType().isVolatileQualified() 5713 << DestType.getNonReferenceType() 5714 << Args[0]->getType() 5715 << Args[0]->getSourceRange(); 5716 break; 5717 5718 case FK_RValueReferenceBindingToLValue: 5719 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref) 5720 << DestType.getNonReferenceType() << Args[0]->getType() 5721 << Args[0]->getSourceRange(); 5722 break; 5723 5724 case FK_ReferenceInitDropsQualifiers: 5725 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals) 5726 << DestType.getNonReferenceType() 5727 << Args[0]->getType() 5728 << Args[0]->getSourceRange(); 5729 break; 5730 5731 case FK_ReferenceInitFailed: 5732 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed) 5733 << DestType.getNonReferenceType() 5734 << Args[0]->isLValue() 5735 << Args[0]->getType() 5736 << Args[0]->getSourceRange(); 5737 if (DestType.getNonReferenceType()->isObjCObjectPointerType() && 5738 Args[0]->getType()->isObjCObjectPointerType()) 5739 S.EmitRelatedResultTypeNote(Args[0]); 5740 break; 5741 5742 case FK_ConversionFailed: { 5743 QualType FromType = Args[0]->getType(); 5744 PartialDiagnostic PDiag = S.PDiag(diag::err_init_conversion_failed) 5745 << (int)Entity.getKind() 5746 << DestType 5747 << Args[0]->isLValue() 5748 << FromType 5749 << Args[0]->getSourceRange(); 5750 S.HandleFunctionTypeMismatch(PDiag, FromType, DestType); 5751 S.Diag(Kind.getLocation(), PDiag); 5752 if (DestType.getNonReferenceType()->isObjCObjectPointerType() && 5753 Args[0]->getType()->isObjCObjectPointerType()) 5754 S.EmitRelatedResultTypeNote(Args[0]); 5755 break; 5756 } 5757 5758 case FK_ConversionFromPropertyFailed: 5759 // No-op. This error has already been reported. 5760 break; 5761 5762 case FK_TooManyInitsForScalar: { 5763 SourceRange R; 5764 5765 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0])) 5766 R = SourceRange(InitList->getInit(0)->getLocEnd(), 5767 InitList->getLocEnd()); 5768 else 5769 R = SourceRange(Args[0]->getLocEnd(), Args[NumArgs - 1]->getLocEnd()); 5770 5771 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin())); 5772 if (Kind.isCStyleOrFunctionalCast()) 5773 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg) 5774 << R; 5775 else 5776 S.Diag(Kind.getLocation(), diag::err_excess_initializers) 5777 << /*scalar=*/2 << R; 5778 break; 5779 } 5780 5781 case FK_ReferenceBindingToInitList: 5782 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list) 5783 << DestType.getNonReferenceType() << Args[0]->getSourceRange(); 5784 break; 5785 5786 case FK_InitListBadDestinationType: 5787 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type) 5788 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange(); 5789 break; 5790 5791 case FK_ListConstructorOverloadFailed: 5792 case FK_ConstructorOverloadFailed: { 5793 SourceRange ArgsRange; 5794 if (NumArgs) 5795 ArgsRange = SourceRange(Args[0]->getLocStart(), 5796 Args[NumArgs - 1]->getLocEnd()); 5797 5798 if (Failure == FK_ListConstructorOverloadFailed) { 5799 assert(NumArgs == 1 && "List construction from other than 1 argument."); 5800 InitListExpr *InitList = cast<InitListExpr>(Args[0]); 5801 Args = InitList->getInits(); 5802 NumArgs = InitList->getNumInits(); 5803 } 5804 5805 // FIXME: Using "DestType" for the entity we're printing is probably 5806 // bad. 5807 switch (FailedOverloadResult) { 5808 case OR_Ambiguous: 5809 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init) 5810 << DestType << ArgsRange; 5811 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, 5812 llvm::makeArrayRef(Args, NumArgs)); 5813 break; 5814 5815 case OR_No_Viable_Function: 5816 if (Kind.getKind() == InitializationKind::IK_Default && 5817 (Entity.getKind() == InitializedEntity::EK_Base || 5818 Entity.getKind() == InitializedEntity::EK_Member) && 5819 isa<CXXConstructorDecl>(S.CurContext)) { 5820 // This is implicit default initialization of a member or 5821 // base within a constructor. If no viable function was 5822 // found, notify the user that she needs to explicitly 5823 // initialize this base/member. 5824 CXXConstructorDecl *Constructor 5825 = cast<CXXConstructorDecl>(S.CurContext); 5826 if (Entity.getKind() == InitializedEntity::EK_Base) { 5827 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor) 5828 << (Constructor->getInheritedConstructor() ? 2 : 5829 Constructor->isImplicit() ? 1 : 0) 5830 << S.Context.getTypeDeclType(Constructor->getParent()) 5831 << /*base=*/0 5832 << Entity.getType(); 5833 5834 RecordDecl *BaseDecl 5835 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>() 5836 ->getDecl(); 5837 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl) 5838 << S.Context.getTagDeclType(BaseDecl); 5839 } else { 5840 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor) 5841 << (Constructor->getInheritedConstructor() ? 2 : 5842 Constructor->isImplicit() ? 1 : 0) 5843 << S.Context.getTypeDeclType(Constructor->getParent()) 5844 << /*member=*/1 5845 << Entity.getName(); 5846 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl); 5847 5848 if (const RecordType *Record 5849 = Entity.getType()->getAs<RecordType>()) 5850 S.Diag(Record->getDecl()->getLocation(), 5851 diag::note_previous_decl) 5852 << S.Context.getTagDeclType(Record->getDecl()); 5853 } 5854 break; 5855 } 5856 5857 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init) 5858 << DestType << ArgsRange; 5859 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, 5860 llvm::makeArrayRef(Args, NumArgs)); 5861 break; 5862 5863 case OR_Deleted: { 5864 OverloadCandidateSet::iterator Best; 5865 OverloadingResult Ovl 5866 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best); 5867 if (Ovl != OR_Deleted) { 5868 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init) 5869 << true << DestType << ArgsRange; 5870 llvm_unreachable("Inconsistent overload resolution?"); 5871 break; 5872 } 5873 5874 // If this is a defaulted or implicitly-declared function, then 5875 // it was implicitly deleted. Make it clear that the deletion was 5876 // implicit. 5877 if (S.isImplicitlyDeleted(Best->Function)) 5878 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init) 5879 << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function)) 5880 << DestType << ArgsRange; 5881 else 5882 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init) 5883 << true << DestType << ArgsRange; 5884 5885 S.NoteDeletedFunction(Best->Function); 5886 break; 5887 } 5888 5889 case OR_Success: 5890 llvm_unreachable("Conversion did not fail!"); 5891 } 5892 } 5893 break; 5894 5895 case FK_DefaultInitOfConst: 5896 if (Entity.getKind() == InitializedEntity::EK_Member && 5897 isa<CXXConstructorDecl>(S.CurContext)) { 5898 // This is implicit default-initialization of a const member in 5899 // a constructor. Complain that it needs to be explicitly 5900 // initialized. 5901 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext); 5902 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor) 5903 << (Constructor->getInheritedConstructor() ? 2 : 5904 Constructor->isImplicit() ? 1 : 0) 5905 << S.Context.getTypeDeclType(Constructor->getParent()) 5906 << /*const=*/1 5907 << Entity.getName(); 5908 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl) 5909 << Entity.getName(); 5910 } else { 5911 S.Diag(Kind.getLocation(), diag::err_default_init_const) 5912 << DestType << (bool)DestType->getAs<RecordType>(); 5913 } 5914 break; 5915 5916 case FK_Incomplete: 5917 S.RequireCompleteType(Kind.getLocation(), FailedIncompleteType, 5918 diag::err_init_incomplete_type); 5919 break; 5920 5921 case FK_ListInitializationFailed: { 5922 // Run the init list checker again to emit diagnostics. 5923 InitListExpr* InitList = cast<InitListExpr>(Args[0]); 5924 QualType DestType = Entity.getType(); 5925 InitListChecker DiagnoseInitList(S, Entity, InitList, 5926 DestType, /*VerifyOnly=*/false, 5927 Kind.getKind() != InitializationKind::IK_DirectList || 5928 !S.getLangOpts().CPlusPlus11); 5929 assert(DiagnoseInitList.HadError() && 5930 "Inconsistent init list check result."); 5931 break; 5932 } 5933 5934 case FK_PlaceholderType: { 5935 // FIXME: Already diagnosed! 5936 break; 5937 } 5938 5939 case FK_InitListElementCopyFailure: { 5940 // Try to perform all copies again. 5941 InitListExpr* InitList = cast<InitListExpr>(Args[0]); 5942 unsigned NumInits = InitList->getNumInits(); 5943 QualType DestType = Entity.getType(); 5944 QualType E; 5945 bool Success = S.isStdInitializerList(DestType, &E); 5946 (void)Success; 5947 assert(Success && "Where did the std::initializer_list go?"); 5948 InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary( 5949 S.Context.getConstantArrayType(E, 5950 llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()), 5951 NumInits), 5952 ArrayType::Normal, 0)); 5953 InitializedEntity Element = InitializedEntity::InitializeElement(S.Context, 5954 0, HiddenArray); 5955 // Show at most 3 errors. Otherwise, you'd get a lot of errors for errors 5956 // where the init list type is wrong, e.g. 5957 // std::initializer_list<void*> list = { 1, 2, 3, 4, 5, 6, 7, 8 }; 5958 // FIXME: Emit a note if we hit the limit? 5959 int ErrorCount = 0; 5960 for (unsigned i = 0; i < NumInits && ErrorCount < 3; ++i) { 5961 Element.setElementIndex(i); 5962 ExprResult Init = S.Owned(InitList->getInit(i)); 5963 if (S.PerformCopyInitialization(Element, Init.get()->getExprLoc(), Init) 5964 .isInvalid()) 5965 ++ErrorCount; 5966 } 5967 break; 5968 } 5969 5970 case FK_ExplicitConstructor: { 5971 S.Diag(Kind.getLocation(), diag::err_selected_explicit_constructor) 5972 << Args[0]->getSourceRange(); 5973 OverloadCandidateSet::iterator Best; 5974 OverloadingResult Ovl 5975 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best); 5976 (void)Ovl; 5977 assert(Ovl == OR_Success && "Inconsistent overload resolution"); 5978 CXXConstructorDecl *CtorDecl = cast<CXXConstructorDecl>(Best->Function); 5979 S.Diag(CtorDecl->getLocation(), diag::note_constructor_declared_here); 5980 break; 5981 } 5982 } 5983 5984 PrintInitLocationNote(S, Entity); 5985 return true; 5986 } 5987 5988 void InitializationSequence::dump(raw_ostream &OS) const { 5989 switch (SequenceKind) { 5990 case FailedSequence: { 5991 OS << "Failed sequence: "; 5992 switch (Failure) { 5993 case FK_TooManyInitsForReference: 5994 OS << "too many initializers for reference"; 5995 break; 5996 5997 case FK_ArrayNeedsInitList: 5998 OS << "array requires initializer list"; 5999 break; 6000 6001 case FK_ArrayNeedsInitListOrStringLiteral: 6002 OS << "array requires initializer list or string literal"; 6003 break; 6004 6005 case FK_ArrayTypeMismatch: 6006 OS << "array type mismatch"; 6007 break; 6008 6009 case FK_NonConstantArrayInit: 6010 OS << "non-constant array initializer"; 6011 break; 6012 6013 case FK_AddressOfOverloadFailed: 6014 OS << "address of overloaded function failed"; 6015 break; 6016 6017 case FK_ReferenceInitOverloadFailed: 6018 OS << "overload resolution for reference initialization failed"; 6019 break; 6020 6021 case FK_NonConstLValueReferenceBindingToTemporary: 6022 OS << "non-const lvalue reference bound to temporary"; 6023 break; 6024 6025 case FK_NonConstLValueReferenceBindingToUnrelated: 6026 OS << "non-const lvalue reference bound to unrelated type"; 6027 break; 6028 6029 case FK_RValueReferenceBindingToLValue: 6030 OS << "rvalue reference bound to an lvalue"; 6031 break; 6032 6033 case FK_ReferenceInitDropsQualifiers: 6034 OS << "reference initialization drops qualifiers"; 6035 break; 6036 6037 case FK_ReferenceInitFailed: 6038 OS << "reference initialization failed"; 6039 break; 6040 6041 case FK_ConversionFailed: 6042 OS << "conversion failed"; 6043 break; 6044 6045 case FK_ConversionFromPropertyFailed: 6046 OS << "conversion from property failed"; 6047 break; 6048 6049 case FK_TooManyInitsForScalar: 6050 OS << "too many initializers for scalar"; 6051 break; 6052 6053 case FK_ReferenceBindingToInitList: 6054 OS << "referencing binding to initializer list"; 6055 break; 6056 6057 case FK_InitListBadDestinationType: 6058 OS << "initializer list for non-aggregate, non-scalar type"; 6059 break; 6060 6061 case FK_UserConversionOverloadFailed: 6062 OS << "overloading failed for user-defined conversion"; 6063 break; 6064 6065 case FK_ConstructorOverloadFailed: 6066 OS << "constructor overloading failed"; 6067 break; 6068 6069 case FK_DefaultInitOfConst: 6070 OS << "default initialization of a const variable"; 6071 break; 6072 6073 case FK_Incomplete: 6074 OS << "initialization of incomplete type"; 6075 break; 6076 6077 case FK_ListInitializationFailed: 6078 OS << "list initialization checker failure"; 6079 break; 6080 6081 case FK_VariableLengthArrayHasInitializer: 6082 OS << "variable length array has an initializer"; 6083 break; 6084 6085 case FK_PlaceholderType: 6086 OS << "initializer expression isn't contextually valid"; 6087 break; 6088 6089 case FK_ListConstructorOverloadFailed: 6090 OS << "list constructor overloading failed"; 6091 break; 6092 6093 case FK_InitListElementCopyFailure: 6094 OS << "copy construction of initializer list element failed"; 6095 break; 6096 6097 case FK_ExplicitConstructor: 6098 OS << "list copy initialization chose explicit constructor"; 6099 break; 6100 } 6101 OS << '\n'; 6102 return; 6103 } 6104 6105 case DependentSequence: 6106 OS << "Dependent sequence\n"; 6107 return; 6108 6109 case NormalSequence: 6110 OS << "Normal sequence: "; 6111 break; 6112 } 6113 6114 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) { 6115 if (S != step_begin()) { 6116 OS << " -> "; 6117 } 6118 6119 switch (S->Kind) { 6120 case SK_ResolveAddressOfOverloadedFunction: 6121 OS << "resolve address of overloaded function"; 6122 break; 6123 6124 case SK_CastDerivedToBaseRValue: 6125 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")"; 6126 break; 6127 6128 case SK_CastDerivedToBaseXValue: 6129 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")"; 6130 break; 6131 6132 case SK_CastDerivedToBaseLValue: 6133 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")"; 6134 break; 6135 6136 case SK_BindReference: 6137 OS << "bind reference to lvalue"; 6138 break; 6139 6140 case SK_BindReferenceToTemporary: 6141 OS << "bind reference to a temporary"; 6142 break; 6143 6144 case SK_ExtraneousCopyToTemporary: 6145 OS << "extraneous C++03 copy to temporary"; 6146 break; 6147 6148 case SK_UserConversion: 6149 OS << "user-defined conversion via " << *S->Function.Function; 6150 break; 6151 6152 case SK_QualificationConversionRValue: 6153 OS << "qualification conversion (rvalue)"; 6154 break; 6155 6156 case SK_QualificationConversionXValue: 6157 OS << "qualification conversion (xvalue)"; 6158 break; 6159 6160 case SK_QualificationConversionLValue: 6161 OS << "qualification conversion (lvalue)"; 6162 break; 6163 6164 case SK_ConversionSequence: 6165 OS << "implicit conversion sequence ("; 6166 S->ICS->DebugPrint(); // FIXME: use OS 6167 OS << ")"; 6168 break; 6169 6170 case SK_ListInitialization: 6171 OS << "list aggregate initialization"; 6172 break; 6173 6174 case SK_ListConstructorCall: 6175 OS << "list initialization via constructor"; 6176 break; 6177 6178 case SK_UnwrapInitList: 6179 OS << "unwrap reference initializer list"; 6180 break; 6181 6182 case SK_RewrapInitList: 6183 OS << "rewrap reference initializer list"; 6184 break; 6185 6186 case SK_ConstructorInitialization: 6187 OS << "constructor initialization"; 6188 break; 6189 6190 case SK_ZeroInitialization: 6191 OS << "zero initialization"; 6192 break; 6193 6194 case SK_CAssignment: 6195 OS << "C assignment"; 6196 break; 6197 6198 case SK_StringInit: 6199 OS << "string initialization"; 6200 break; 6201 6202 case SK_ObjCObjectConversion: 6203 OS << "Objective-C object conversion"; 6204 break; 6205 6206 case SK_ArrayInit: 6207 OS << "array initialization"; 6208 break; 6209 6210 case SK_ParenthesizedArrayInit: 6211 OS << "parenthesized array initialization"; 6212 break; 6213 6214 case SK_PassByIndirectCopyRestore: 6215 OS << "pass by indirect copy and restore"; 6216 break; 6217 6218 case SK_PassByIndirectRestore: 6219 OS << "pass by indirect restore"; 6220 break; 6221 6222 case SK_ProduceObjCObject: 6223 OS << "Objective-C object retension"; 6224 break; 6225 6226 case SK_StdInitializerList: 6227 OS << "std::initializer_list from initializer list"; 6228 break; 6229 6230 case SK_OCLSamplerInit: 6231 OS << "OpenCL sampler_t from integer constant"; 6232 break; 6233 6234 case SK_OCLZeroEvent: 6235 OS << "OpenCL event_t from zero"; 6236 break; 6237 } 6238 6239 OS << " [" << S->Type.getAsString() << ']'; 6240 } 6241 6242 OS << '\n'; 6243 } 6244 6245 void InitializationSequence::dump() const { 6246 dump(llvm::errs()); 6247 } 6248 6249 static void DiagnoseNarrowingInInitList(Sema &S, InitializationSequence &Seq, 6250 QualType EntityType, 6251 const Expr *PreInit, 6252 const Expr *PostInit) { 6253 if (Seq.step_begin() == Seq.step_end() || PreInit->isValueDependent()) 6254 return; 6255 6256 // A narrowing conversion can only appear as the final implicit conversion in 6257 // an initialization sequence. 6258 const InitializationSequence::Step &LastStep = Seq.step_end()[-1]; 6259 if (LastStep.Kind != InitializationSequence::SK_ConversionSequence) 6260 return; 6261 6262 const ImplicitConversionSequence &ICS = *LastStep.ICS; 6263 const StandardConversionSequence *SCS = 0; 6264 switch (ICS.getKind()) { 6265 case ImplicitConversionSequence::StandardConversion: 6266 SCS = &ICS.Standard; 6267 break; 6268 case ImplicitConversionSequence::UserDefinedConversion: 6269 SCS = &ICS.UserDefined.After; 6270 break; 6271 case ImplicitConversionSequence::AmbiguousConversion: 6272 case ImplicitConversionSequence::EllipsisConversion: 6273 case ImplicitConversionSequence::BadConversion: 6274 return; 6275 } 6276 6277 // Determine the type prior to the narrowing conversion. If a conversion 6278 // operator was used, this may be different from both the type of the entity 6279 // and of the pre-initialization expression. 6280 QualType PreNarrowingType = PreInit->getType(); 6281 if (Seq.step_begin() + 1 != Seq.step_end()) 6282 PreNarrowingType = Seq.step_end()[-2].Type; 6283 6284 // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion. 6285 APValue ConstantValue; 6286 QualType ConstantType; 6287 switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue, 6288 ConstantType)) { 6289 case NK_Not_Narrowing: 6290 // No narrowing occurred. 6291 return; 6292 6293 case NK_Type_Narrowing: 6294 // This was a floating-to-integer conversion, which is always considered a 6295 // narrowing conversion even if the value is a constant and can be 6296 // represented exactly as an integer. 6297 S.Diag(PostInit->getLocStart(), 6298 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11? 6299 diag::warn_init_list_type_narrowing 6300 : S.isSFINAEContext()? 6301 diag::err_init_list_type_narrowing_sfinae 6302 : diag::err_init_list_type_narrowing) 6303 << PostInit->getSourceRange() 6304 << PreNarrowingType.getLocalUnqualifiedType() 6305 << EntityType.getLocalUnqualifiedType(); 6306 break; 6307 6308 case NK_Constant_Narrowing: 6309 // A constant value was narrowed. 6310 S.Diag(PostInit->getLocStart(), 6311 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11? 6312 diag::warn_init_list_constant_narrowing 6313 : S.isSFINAEContext()? 6314 diag::err_init_list_constant_narrowing_sfinae 6315 : diag::err_init_list_constant_narrowing) 6316 << PostInit->getSourceRange() 6317 << ConstantValue.getAsString(S.getASTContext(), ConstantType) 6318 << EntityType.getLocalUnqualifiedType(); 6319 break; 6320 6321 case NK_Variable_Narrowing: 6322 // A variable's value may have been narrowed. 6323 S.Diag(PostInit->getLocStart(), 6324 S.getLangOpts().MicrosoftExt || !S.getLangOpts().CPlusPlus11? 6325 diag::warn_init_list_variable_narrowing 6326 : S.isSFINAEContext()? 6327 diag::err_init_list_variable_narrowing_sfinae 6328 : diag::err_init_list_variable_narrowing) 6329 << PostInit->getSourceRange() 6330 << PreNarrowingType.getLocalUnqualifiedType() 6331 << EntityType.getLocalUnqualifiedType(); 6332 break; 6333 } 6334 6335 SmallString<128> StaticCast; 6336 llvm::raw_svector_ostream OS(StaticCast); 6337 OS << "static_cast<"; 6338 if (const TypedefType *TT = EntityType->getAs<TypedefType>()) { 6339 // It's important to use the typedef's name if there is one so that the 6340 // fixit doesn't break code using types like int64_t. 6341 // 6342 // FIXME: This will break if the typedef requires qualification. But 6343 // getQualifiedNameAsString() includes non-machine-parsable components. 6344 OS << *TT->getDecl(); 6345 } else if (const BuiltinType *BT = EntityType->getAs<BuiltinType>()) 6346 OS << BT->getName(S.getLangOpts()); 6347 else { 6348 // Oops, we didn't find the actual type of the variable. Don't emit a fixit 6349 // with a broken cast. 6350 return; 6351 } 6352 OS << ">("; 6353 S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override) 6354 << PostInit->getSourceRange() 6355 << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str()) 6356 << FixItHint::CreateInsertion( 6357 S.getPreprocessor().getLocForEndOfToken(PostInit->getLocEnd()), ")"); 6358 } 6359 6360 //===----------------------------------------------------------------------===// 6361 // Initialization helper functions 6362 //===----------------------------------------------------------------------===// 6363 bool 6364 Sema::CanPerformCopyInitialization(const InitializedEntity &Entity, 6365 ExprResult Init) { 6366 if (Init.isInvalid()) 6367 return false; 6368 6369 Expr *InitE = Init.get(); 6370 assert(InitE && "No initialization expression"); 6371 6372 InitializationKind Kind 6373 = InitializationKind::CreateCopy(InitE->getLocStart(), SourceLocation()); 6374 InitializationSequence Seq(*this, Entity, Kind, &InitE, 1); 6375 return !Seq.Failed(); 6376 } 6377 6378 ExprResult 6379 Sema::PerformCopyInitialization(const InitializedEntity &Entity, 6380 SourceLocation EqualLoc, 6381 ExprResult Init, 6382 bool TopLevelOfInitList, 6383 bool AllowExplicit) { 6384 if (Init.isInvalid()) 6385 return ExprError(); 6386 6387 Expr *InitE = Init.get(); 6388 assert(InitE && "No initialization expression?"); 6389 6390 if (EqualLoc.isInvalid()) 6391 EqualLoc = InitE->getLocStart(); 6392 6393 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(), 6394 EqualLoc, 6395 AllowExplicit); 6396 InitializationSequence Seq(*this, Entity, Kind, &InitE, 1); 6397 Init.release(); 6398 6399 ExprResult Result = Seq.Perform(*this, Entity, Kind, MultiExprArg(&InitE, 1)); 6400 6401 if (!Result.isInvalid() && TopLevelOfInitList) 6402 DiagnoseNarrowingInInitList(*this, Seq, Entity.getType(), 6403 InitE, Result.get()); 6404 6405 return Result; 6406 } 6407