SemaInit.cpp revision cc15f010672a13b38104a32e3cefc7adc07ffbf7
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. The main entry 11// point is Sema::CheckInitList(), but all of the work is performed 12// within the InitListChecker class. 13// 14//===----------------------------------------------------------------------===// 15 16#include "clang/Sema/Designator.h" 17#include "clang/Sema/Initialization.h" 18#include "clang/Sema/Lookup.h" 19#include "clang/Sema/SemaInternal.h" 20#include "clang/Lex/Preprocessor.h" 21#include "clang/AST/ASTContext.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/ExprCXX.h" 24#include "clang/AST/ExprObjC.h" 25#include "clang/AST/TypeLoc.h" 26#include "llvm/Support/ErrorHandling.h" 27#include <map> 28using namespace clang; 29 30//===----------------------------------------------------------------------===// 31// Sema Initialization Checking 32//===----------------------------------------------------------------------===// 33 34static Expr *IsStringInit(Expr *Init, QualType DeclType, ASTContext &Context) { 35 const ArrayType *AT = Context.getAsArrayType(DeclType); 36 if (!AT) return 0; 37 38 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT)) 39 return 0; 40 41 // See if this is a string literal or @encode. 42 Init = Init->IgnoreParens(); 43 44 // Handle @encode, which is a narrow string. 45 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType()) 46 return Init; 47 48 // Otherwise we can only handle string literals. 49 StringLiteral *SL = dyn_cast<StringLiteral>(Init); 50 if (SL == 0) return 0; 51 52 QualType ElemTy = Context.getCanonicalType(AT->getElementType()); 53 // char array can be initialized with a narrow string. 54 // Only allow char x[] = "foo"; not char x[] = L"foo"; 55 if (!SL->isWide()) 56 return ElemTy->isCharType() ? Init : 0; 57 58 // wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with 59 // correction from DR343): "An array with element type compatible with a 60 // qualified or unqualified version of wchar_t may be initialized by a wide 61 // string literal, optionally enclosed in braces." 62 if (Context.typesAreCompatible(Context.getWCharType(), 63 ElemTy.getUnqualifiedType())) 64 return Init; 65 66 return 0; 67} 68 69static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) { 70 // Get the length of the string as parsed. 71 uint64_t StrLength = 72 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue(); 73 74 75 const ArrayType *AT = S.Context.getAsArrayType(DeclT); 76 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 77 // C99 6.7.8p14. We have an array of character type with unknown size 78 // being initialized to a string literal. 79 llvm::APSInt ConstVal(32); 80 ConstVal = StrLength; 81 // Return a new array type (C99 6.7.8p22). 82 DeclT = S.Context.getConstantArrayType(IAT->getElementType(), 83 ConstVal, 84 ArrayType::Normal, 0); 85 return; 86 } 87 88 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 89 90 // C99 6.7.8p14. We have an array of character type with known size. However, 91 // the size may be smaller or larger than the string we are initializing. 92 // FIXME: Avoid truncation for 64-bit length strings. 93 if (StrLength-1 > CAT->getSize().getZExtValue()) 94 S.Diag(Str->getSourceRange().getBegin(), 95 diag::warn_initializer_string_for_char_array_too_long) 96 << Str->getSourceRange(); 97 98 // Set the type to the actual size that we are initializing. If we have 99 // something like: 100 // char x[1] = "foo"; 101 // then this will set the string literal's type to char[1]. 102 Str->setType(DeclT); 103} 104 105//===----------------------------------------------------------------------===// 106// Semantic checking for initializer lists. 107//===----------------------------------------------------------------------===// 108 109/// @brief Semantic checking for initializer lists. 110/// 111/// The InitListChecker class contains a set of routines that each 112/// handle the initialization of a certain kind of entity, e.g., 113/// arrays, vectors, struct/union types, scalars, etc. The 114/// InitListChecker itself performs a recursive walk of the subobject 115/// structure of the type to be initialized, while stepping through 116/// the initializer list one element at a time. The IList and Index 117/// parameters to each of the Check* routines contain the active 118/// (syntactic) initializer list and the index into that initializer 119/// list that represents the current initializer. Each routine is 120/// responsible for moving that Index forward as it consumes elements. 121/// 122/// Each Check* routine also has a StructuredList/StructuredIndex 123/// arguments, which contains the current the "structured" (semantic) 124/// initializer list and the index into that initializer list where we 125/// are copying initializers as we map them over to the semantic 126/// list. Once we have completed our recursive walk of the subobject 127/// structure, we will have constructed a full semantic initializer 128/// list. 129/// 130/// C99 designators cause changes in the initializer list traversal, 131/// because they make the initialization "jump" into a specific 132/// subobject and then continue the initialization from that 133/// point. CheckDesignatedInitializer() recursively steps into the 134/// designated subobject and manages backing out the recursion to 135/// initialize the subobjects after the one designated. 136namespace { 137class InitListChecker { 138 Sema &SemaRef; 139 bool hadError; 140 std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic; 141 InitListExpr *FullyStructuredList; 142 143 void CheckImplicitInitList(const InitializedEntity &Entity, 144 InitListExpr *ParentIList, QualType T, 145 unsigned &Index, InitListExpr *StructuredList, 146 unsigned &StructuredIndex, 147 bool TopLevelObject = false); 148 void CheckExplicitInitList(const InitializedEntity &Entity, 149 InitListExpr *IList, QualType &T, 150 unsigned &Index, InitListExpr *StructuredList, 151 unsigned &StructuredIndex, 152 bool TopLevelObject = false); 153 void CheckListElementTypes(const InitializedEntity &Entity, 154 InitListExpr *IList, QualType &DeclType, 155 bool SubobjectIsDesignatorContext, 156 unsigned &Index, 157 InitListExpr *StructuredList, 158 unsigned &StructuredIndex, 159 bool TopLevelObject = false); 160 void CheckSubElementType(const InitializedEntity &Entity, 161 InitListExpr *IList, QualType ElemType, 162 unsigned &Index, 163 InitListExpr *StructuredList, 164 unsigned &StructuredIndex); 165 void CheckScalarType(const InitializedEntity &Entity, 166 InitListExpr *IList, QualType DeclType, 167 unsigned &Index, 168 InitListExpr *StructuredList, 169 unsigned &StructuredIndex); 170 void CheckReferenceType(const InitializedEntity &Entity, 171 InitListExpr *IList, QualType DeclType, 172 unsigned &Index, 173 InitListExpr *StructuredList, 174 unsigned &StructuredIndex); 175 void CheckVectorType(const InitializedEntity &Entity, 176 InitListExpr *IList, QualType DeclType, unsigned &Index, 177 InitListExpr *StructuredList, 178 unsigned &StructuredIndex); 179 void CheckStructUnionTypes(const InitializedEntity &Entity, 180 InitListExpr *IList, QualType DeclType, 181 RecordDecl::field_iterator Field, 182 bool SubobjectIsDesignatorContext, unsigned &Index, 183 InitListExpr *StructuredList, 184 unsigned &StructuredIndex, 185 bool TopLevelObject = false); 186 void CheckArrayType(const InitializedEntity &Entity, 187 InitListExpr *IList, QualType &DeclType, 188 llvm::APSInt elementIndex, 189 bool SubobjectIsDesignatorContext, unsigned &Index, 190 InitListExpr *StructuredList, 191 unsigned &StructuredIndex); 192 bool CheckDesignatedInitializer(const InitializedEntity &Entity, 193 InitListExpr *IList, DesignatedInitExpr *DIE, 194 unsigned DesigIdx, 195 QualType &CurrentObjectType, 196 RecordDecl::field_iterator *NextField, 197 llvm::APSInt *NextElementIndex, 198 unsigned &Index, 199 InitListExpr *StructuredList, 200 unsigned &StructuredIndex, 201 bool FinishSubobjectInit, 202 bool TopLevelObject); 203 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 204 QualType CurrentObjectType, 205 InitListExpr *StructuredList, 206 unsigned StructuredIndex, 207 SourceRange InitRange); 208 void UpdateStructuredListElement(InitListExpr *StructuredList, 209 unsigned &StructuredIndex, 210 Expr *expr); 211 int numArrayElements(QualType DeclType); 212 int numStructUnionElements(QualType DeclType); 213 214 void FillInValueInitForField(unsigned Init, FieldDecl *Field, 215 const InitializedEntity &ParentEntity, 216 InitListExpr *ILE, bool &RequiresSecondPass); 217 void FillInValueInitializations(const InitializedEntity &Entity, 218 InitListExpr *ILE, bool &RequiresSecondPass); 219public: 220 InitListChecker(Sema &S, const InitializedEntity &Entity, 221 InitListExpr *IL, QualType &T); 222 bool HadError() { return hadError; } 223 224 // @brief Retrieves the fully-structured initializer list used for 225 // semantic analysis and code generation. 226 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; } 227}; 228} // end anonymous namespace 229 230void InitListChecker::FillInValueInitForField(unsigned Init, FieldDecl *Field, 231 const InitializedEntity &ParentEntity, 232 InitListExpr *ILE, 233 bool &RequiresSecondPass) { 234 SourceLocation Loc = ILE->getSourceRange().getBegin(); 235 unsigned NumInits = ILE->getNumInits(); 236 InitializedEntity MemberEntity 237 = InitializedEntity::InitializeMember(Field, &ParentEntity); 238 if (Init >= NumInits || !ILE->getInit(Init)) { 239 // FIXME: We probably don't need to handle references 240 // specially here, since value-initialization of references is 241 // handled in InitializationSequence. 242 if (Field->getType()->isReferenceType()) { 243 // C++ [dcl.init.aggr]p9: 244 // If an incomplete or empty initializer-list leaves a 245 // member of reference type uninitialized, the program is 246 // ill-formed. 247 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized) 248 << Field->getType() 249 << ILE->getSyntacticForm()->getSourceRange(); 250 SemaRef.Diag(Field->getLocation(), 251 diag::note_uninit_reference_member); 252 hadError = true; 253 return; 254 } 255 256 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc, 257 true); 258 InitializationSequence InitSeq(SemaRef, MemberEntity, Kind, 0, 0); 259 if (!InitSeq) { 260 InitSeq.Diagnose(SemaRef, MemberEntity, Kind, 0, 0); 261 hadError = true; 262 return; 263 } 264 265 ExprResult MemberInit 266 = InitSeq.Perform(SemaRef, MemberEntity, Kind, MultiExprArg()); 267 if (MemberInit.isInvalid()) { 268 hadError = true; 269 return; 270 } 271 272 if (hadError) { 273 // Do nothing 274 } else if (Init < NumInits) { 275 ILE->setInit(Init, MemberInit.takeAs<Expr>()); 276 } else if (InitSeq.getKind() 277 == InitializationSequence::ConstructorInitialization) { 278 // Value-initialization requires a constructor call, so 279 // extend the initializer list to include the constructor 280 // call and make a note that we'll need to take another pass 281 // through the initializer list. 282 ILE->updateInit(SemaRef.Context, Init, MemberInit.takeAs<Expr>()); 283 RequiresSecondPass = true; 284 } 285 } else if (InitListExpr *InnerILE 286 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 287 FillInValueInitializations(MemberEntity, InnerILE, 288 RequiresSecondPass); 289} 290 291/// Recursively replaces NULL values within the given initializer list 292/// with expressions that perform value-initialization of the 293/// appropriate type. 294void 295InitListChecker::FillInValueInitializations(const InitializedEntity &Entity, 296 InitListExpr *ILE, 297 bool &RequiresSecondPass) { 298 assert((ILE->getType() != SemaRef.Context.VoidTy) && 299 "Should not have void type"); 300 SourceLocation Loc = ILE->getSourceRange().getBegin(); 301 if (ILE->getSyntacticForm()) 302 Loc = ILE->getSyntacticForm()->getSourceRange().getBegin(); 303 304 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) { 305 if (RType->getDecl()->isUnion() && 306 ILE->getInitializedFieldInUnion()) 307 FillInValueInitForField(0, ILE->getInitializedFieldInUnion(), 308 Entity, ILE, RequiresSecondPass); 309 else { 310 unsigned Init = 0; 311 for (RecordDecl::field_iterator 312 Field = RType->getDecl()->field_begin(), 313 FieldEnd = RType->getDecl()->field_end(); 314 Field != FieldEnd; ++Field) { 315 if (Field->isUnnamedBitfield()) 316 continue; 317 318 if (hadError) 319 return; 320 321 FillInValueInitForField(Init, *Field, Entity, ILE, RequiresSecondPass); 322 if (hadError) 323 return; 324 325 ++Init; 326 327 // Only look at the first initialization of a union. 328 if (RType->getDecl()->isUnion()) 329 break; 330 } 331 } 332 333 return; 334 } 335 336 QualType ElementType; 337 338 InitializedEntity ElementEntity = Entity; 339 unsigned NumInits = ILE->getNumInits(); 340 unsigned NumElements = NumInits; 341 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) { 342 ElementType = AType->getElementType(); 343 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) 344 NumElements = CAType->getSize().getZExtValue(); 345 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context, 346 0, Entity); 347 } else if (const VectorType *VType = ILE->getType()->getAs<VectorType>()) { 348 ElementType = VType->getElementType(); 349 NumElements = VType->getNumElements(); 350 ElementEntity = InitializedEntity::InitializeElement(SemaRef.Context, 351 0, Entity); 352 } else 353 ElementType = ILE->getType(); 354 355 356 for (unsigned Init = 0; Init != NumElements; ++Init) { 357 if (hadError) 358 return; 359 360 if (ElementEntity.getKind() == InitializedEntity::EK_ArrayElement || 361 ElementEntity.getKind() == InitializedEntity::EK_VectorElement) 362 ElementEntity.setElementIndex(Init); 363 364 if (Init >= NumInits || !ILE->getInit(Init)) { 365 InitializationKind Kind = InitializationKind::CreateValue(Loc, Loc, Loc, 366 true); 367 InitializationSequence InitSeq(SemaRef, ElementEntity, Kind, 0, 0); 368 if (!InitSeq) { 369 InitSeq.Diagnose(SemaRef, ElementEntity, Kind, 0, 0); 370 hadError = true; 371 return; 372 } 373 374 ExprResult ElementInit 375 = InitSeq.Perform(SemaRef, ElementEntity, Kind, MultiExprArg()); 376 if (ElementInit.isInvalid()) { 377 hadError = true; 378 return; 379 } 380 381 if (hadError) { 382 // Do nothing 383 } else if (Init < NumInits) { 384 ILE->setInit(Init, ElementInit.takeAs<Expr>()); 385 } else if (InitSeq.getKind() 386 == InitializationSequence::ConstructorInitialization) { 387 // Value-initialization requires a constructor call, so 388 // extend the initializer list to include the constructor 389 // call and make a note that we'll need to take another pass 390 // through the initializer list. 391 ILE->updateInit(SemaRef.Context, Init, ElementInit.takeAs<Expr>()); 392 RequiresSecondPass = true; 393 } 394 } else if (InitListExpr *InnerILE 395 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 396 FillInValueInitializations(ElementEntity, InnerILE, RequiresSecondPass); 397 } 398} 399 400 401InitListChecker::InitListChecker(Sema &S, const InitializedEntity &Entity, 402 InitListExpr *IL, QualType &T) 403 : SemaRef(S) { 404 hadError = false; 405 406 unsigned newIndex = 0; 407 unsigned newStructuredIndex = 0; 408 FullyStructuredList 409 = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange()); 410 CheckExplicitInitList(Entity, IL, T, newIndex, 411 FullyStructuredList, newStructuredIndex, 412 /*TopLevelObject=*/true); 413 414 if (!hadError) { 415 bool RequiresSecondPass = false; 416 FillInValueInitializations(Entity, FullyStructuredList, RequiresSecondPass); 417 if (RequiresSecondPass && !hadError) 418 FillInValueInitializations(Entity, FullyStructuredList, 419 RequiresSecondPass); 420 } 421} 422 423int InitListChecker::numArrayElements(QualType DeclType) { 424 // FIXME: use a proper constant 425 int maxElements = 0x7FFFFFFF; 426 if (const ConstantArrayType *CAT = 427 SemaRef.Context.getAsConstantArrayType(DeclType)) { 428 maxElements = static_cast<int>(CAT->getSize().getZExtValue()); 429 } 430 return maxElements; 431} 432 433int InitListChecker::numStructUnionElements(QualType DeclType) { 434 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl(); 435 int InitializableMembers = 0; 436 for (RecordDecl::field_iterator 437 Field = structDecl->field_begin(), 438 FieldEnd = structDecl->field_end(); 439 Field != FieldEnd; ++Field) { 440 if ((*Field)->getIdentifier() || !(*Field)->isBitField()) 441 ++InitializableMembers; 442 } 443 if (structDecl->isUnion()) 444 return std::min(InitializableMembers, 1); 445 return InitializableMembers - structDecl->hasFlexibleArrayMember(); 446} 447 448void InitListChecker::CheckImplicitInitList(const InitializedEntity &Entity, 449 InitListExpr *ParentIList, 450 QualType T, unsigned &Index, 451 InitListExpr *StructuredList, 452 unsigned &StructuredIndex, 453 bool TopLevelObject) { 454 int maxElements = 0; 455 456 if (T->isArrayType()) 457 maxElements = numArrayElements(T); 458 else if (T->isRecordType()) 459 maxElements = numStructUnionElements(T); 460 else if (T->isVectorType()) 461 maxElements = T->getAs<VectorType>()->getNumElements(); 462 else 463 assert(0 && "CheckImplicitInitList(): Illegal type"); 464 465 if (maxElements == 0) { 466 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(), 467 diag::err_implicit_empty_initializer); 468 ++Index; 469 hadError = true; 470 return; 471 } 472 473 // Build a structured initializer list corresponding to this subobject. 474 InitListExpr *StructuredSubobjectInitList 475 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList, 476 StructuredIndex, 477 SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(), 478 ParentIList->getSourceRange().getEnd())); 479 unsigned StructuredSubobjectInitIndex = 0; 480 481 // Check the element types and build the structural subobject. 482 unsigned StartIndex = Index; 483 CheckListElementTypes(Entity, ParentIList, T, 484 /*SubobjectIsDesignatorContext=*/false, Index, 485 StructuredSubobjectInitList, 486 StructuredSubobjectInitIndex, 487 TopLevelObject); 488 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1); 489 StructuredSubobjectInitList->setType(T); 490 491 // Update the structured sub-object initializer so that it's ending 492 // range corresponds with the end of the last initializer it used. 493 if (EndIndex < ParentIList->getNumInits()) { 494 SourceLocation EndLoc 495 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd(); 496 StructuredSubobjectInitList->setRBraceLoc(EndLoc); 497 } 498 499 // Warn about missing braces. 500 if (T->isArrayType() || T->isRecordType()) { 501 SemaRef.Diag(StructuredSubobjectInitList->getLocStart(), 502 diag::warn_missing_braces) 503 << StructuredSubobjectInitList->getSourceRange() 504 << FixItHint::CreateInsertion(StructuredSubobjectInitList->getLocStart(), 505 "{") 506 << FixItHint::CreateInsertion(SemaRef.PP.getLocForEndOfToken( 507 StructuredSubobjectInitList->getLocEnd()), 508 "}"); 509 } 510} 511 512void InitListChecker::CheckExplicitInitList(const InitializedEntity &Entity, 513 InitListExpr *IList, QualType &T, 514 unsigned &Index, 515 InitListExpr *StructuredList, 516 unsigned &StructuredIndex, 517 bool TopLevelObject) { 518 assert(IList->isExplicit() && "Illegal Implicit InitListExpr"); 519 SyntacticToSemantic[IList] = StructuredList; 520 StructuredList->setSyntacticForm(IList); 521 CheckListElementTypes(Entity, IList, T, /*SubobjectIsDesignatorContext=*/true, 522 Index, StructuredList, StructuredIndex, TopLevelObject); 523 QualType ExprTy = T.getNonLValueExprType(SemaRef.Context); 524 IList->setType(ExprTy); 525 StructuredList->setType(ExprTy); 526 if (hadError) 527 return; 528 529 if (Index < IList->getNumInits()) { 530 // We have leftover initializers 531 if (StructuredIndex == 1 && 532 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) { 533 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer; 534 if (SemaRef.getLangOptions().CPlusPlus) { 535 DK = diag::err_excess_initializers_in_char_array_initializer; 536 hadError = true; 537 } 538 // Special-case 539 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 540 << IList->getInit(Index)->getSourceRange(); 541 } else if (!T->isIncompleteType()) { 542 // Don't complain for incomplete types, since we'll get an error 543 // elsewhere 544 QualType CurrentObjectType = StructuredList->getType(); 545 int initKind = 546 CurrentObjectType->isArrayType()? 0 : 547 CurrentObjectType->isVectorType()? 1 : 548 CurrentObjectType->isScalarType()? 2 : 549 CurrentObjectType->isUnionType()? 3 : 550 4; 551 552 unsigned DK = diag::warn_excess_initializers; 553 if (SemaRef.getLangOptions().CPlusPlus) { 554 DK = diag::err_excess_initializers; 555 hadError = true; 556 } 557 if (SemaRef.getLangOptions().OpenCL && initKind == 1) { 558 DK = diag::err_excess_initializers; 559 hadError = true; 560 } 561 562 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 563 << initKind << IList->getInit(Index)->getSourceRange(); 564 } 565 } 566 567 if (T->isScalarType() && !TopLevelObject) 568 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init) 569 << IList->getSourceRange() 570 << FixItHint::CreateRemoval(IList->getLocStart()) 571 << FixItHint::CreateRemoval(IList->getLocEnd()); 572} 573 574void InitListChecker::CheckListElementTypes(const InitializedEntity &Entity, 575 InitListExpr *IList, 576 QualType &DeclType, 577 bool SubobjectIsDesignatorContext, 578 unsigned &Index, 579 InitListExpr *StructuredList, 580 unsigned &StructuredIndex, 581 bool TopLevelObject) { 582 if (DeclType->isScalarType()) { 583 CheckScalarType(Entity, IList, DeclType, Index, 584 StructuredList, StructuredIndex); 585 } else if (DeclType->isVectorType()) { 586 CheckVectorType(Entity, IList, DeclType, Index, 587 StructuredList, StructuredIndex); 588 } else if (DeclType->isAggregateType()) { 589 if (DeclType->isRecordType()) { 590 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 591 CheckStructUnionTypes(Entity, IList, DeclType, RD->field_begin(), 592 SubobjectIsDesignatorContext, Index, 593 StructuredList, StructuredIndex, 594 TopLevelObject); 595 } else if (DeclType->isArrayType()) { 596 llvm::APSInt Zero( 597 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()), 598 false); 599 CheckArrayType(Entity, IList, DeclType, Zero, 600 SubobjectIsDesignatorContext, Index, 601 StructuredList, StructuredIndex); 602 } else 603 assert(0 && "Aggregate that isn't a structure or array?!"); 604 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) { 605 // This type is invalid, issue a diagnostic. 606 ++Index; 607 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 608 << DeclType; 609 hadError = true; 610 } else if (DeclType->isRecordType()) { 611 // C++ [dcl.init]p14: 612 // [...] If the class is an aggregate (8.5.1), and the initializer 613 // is a brace-enclosed list, see 8.5.1. 614 // 615 // Note: 8.5.1 is handled below; here, we diagnose the case where 616 // we have an initializer list and a destination type that is not 617 // an aggregate. 618 // FIXME: In C++0x, this is yet another form of initialization. 619 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 620 << DeclType << IList->getSourceRange(); 621 hadError = true; 622 } else if (DeclType->isReferenceType()) { 623 CheckReferenceType(Entity, IList, DeclType, Index, 624 StructuredList, StructuredIndex); 625 } else if (DeclType->isObjCObjectType()) { 626 SemaRef.Diag(IList->getLocStart(), diag::err_init_objc_class) 627 << DeclType; 628 hadError = true; 629 } else { 630 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 631 << DeclType; 632 hadError = true; 633 } 634} 635 636void InitListChecker::CheckSubElementType(const InitializedEntity &Entity, 637 InitListExpr *IList, 638 QualType ElemType, 639 unsigned &Index, 640 InitListExpr *StructuredList, 641 unsigned &StructuredIndex) { 642 Expr *expr = IList->getInit(Index); 643 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) { 644 unsigned newIndex = 0; 645 unsigned newStructuredIndex = 0; 646 InitListExpr *newStructuredList 647 = getStructuredSubobjectInit(IList, Index, ElemType, 648 StructuredList, StructuredIndex, 649 SubInitList->getSourceRange()); 650 CheckExplicitInitList(Entity, SubInitList, ElemType, newIndex, 651 newStructuredList, newStructuredIndex); 652 ++StructuredIndex; 653 ++Index; 654 } else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) { 655 CheckStringInit(Str, ElemType, SemaRef); 656 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 657 ++Index; 658 } else if (ElemType->isScalarType()) { 659 CheckScalarType(Entity, IList, ElemType, Index, 660 StructuredList, StructuredIndex); 661 } else if (ElemType->isReferenceType()) { 662 CheckReferenceType(Entity, IList, ElemType, Index, 663 StructuredList, StructuredIndex); 664 } else { 665 if (SemaRef.getLangOptions().CPlusPlus) { 666 // C++ [dcl.init.aggr]p12: 667 // All implicit type conversions (clause 4) are considered when 668 // initializing the aggregate member with an ini- tializer from 669 // an initializer-list. If the initializer can initialize a 670 // member, the member is initialized. [...] 671 672 // FIXME: Better EqualLoc? 673 InitializationKind Kind = 674 InitializationKind::CreateCopy(expr->getLocStart(), SourceLocation()); 675 InitializationSequence Seq(SemaRef, Entity, Kind, &expr, 1); 676 677 if (Seq) { 678 ExprResult Result = 679 Seq.Perform(SemaRef, Entity, Kind, MultiExprArg(&expr, 1)); 680 if (Result.isInvalid()) 681 hadError = true; 682 683 UpdateStructuredListElement(StructuredList, StructuredIndex, 684 Result.takeAs<Expr>()); 685 ++Index; 686 return; 687 } 688 689 // Fall through for subaggregate initialization 690 } else { 691 // C99 6.7.8p13: 692 // 693 // The initializer for a structure or union object that has 694 // automatic storage duration shall be either an initializer 695 // list as described below, or a single expression that has 696 // compatible structure or union type. In the latter case, the 697 // initial value of the object, including unnamed members, is 698 // that of the expression. 699 if ((ElemType->isRecordType() || ElemType->isVectorType()) && 700 SemaRef.Context.hasSameUnqualifiedType(expr->getType(), ElemType)) { 701 SemaRef.DefaultFunctionArrayLvalueConversion(expr); 702 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 703 ++Index; 704 return; 705 } 706 707 // Fall through for subaggregate initialization 708 } 709 710 // C++ [dcl.init.aggr]p12: 711 // 712 // [...] Otherwise, if the member is itself a non-empty 713 // subaggregate, brace elision is assumed and the initializer is 714 // considered for the initialization of the first member of 715 // the subaggregate. 716 if (ElemType->isAggregateType() || ElemType->isVectorType()) { 717 CheckImplicitInitList(Entity, IList, ElemType, Index, StructuredList, 718 StructuredIndex); 719 ++StructuredIndex; 720 } else { 721 // We cannot initialize this element, so let 722 // PerformCopyInitialization produce the appropriate diagnostic. 723 SemaRef.PerformCopyInitialization(Entity, SourceLocation(), 724 SemaRef.Owned(expr)); 725 hadError = true; 726 ++Index; 727 ++StructuredIndex; 728 } 729 } 730} 731 732void InitListChecker::CheckScalarType(const InitializedEntity &Entity, 733 InitListExpr *IList, QualType DeclType, 734 unsigned &Index, 735 InitListExpr *StructuredList, 736 unsigned &StructuredIndex) { 737 if (Index >= IList->getNumInits()) { 738 SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer) 739 << IList->getSourceRange(); 740 hadError = true; 741 ++Index; 742 ++StructuredIndex; 743 return; 744 } 745 746 Expr *expr = IList->getInit(Index); 747 if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) { 748 SemaRef.Diag(SubIList->getLocStart(), 749 diag::warn_many_braces_around_scalar_init) 750 << SubIList->getSourceRange(); 751 752 CheckScalarType(Entity, SubIList, DeclType, Index, StructuredList, 753 StructuredIndex); 754 return; 755 } else if (isa<DesignatedInitExpr>(expr)) { 756 SemaRef.Diag(expr->getSourceRange().getBegin(), 757 diag::err_designator_for_scalar_init) 758 << DeclType << expr->getSourceRange(); 759 hadError = true; 760 ++Index; 761 ++StructuredIndex; 762 return; 763 } 764 765 ExprResult Result = 766 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), 767 SemaRef.Owned(expr)); 768 769 Expr *ResultExpr = 0; 770 771 if (Result.isInvalid()) 772 hadError = true; // types weren't compatible. 773 else { 774 ResultExpr = Result.takeAs<Expr>(); 775 776 if (ResultExpr != expr) { 777 // The type was promoted, update initializer list. 778 IList->setInit(Index, ResultExpr); 779 } 780 } 781 if (hadError) 782 ++StructuredIndex; 783 else 784 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr); 785 ++Index; 786} 787 788void InitListChecker::CheckReferenceType(const InitializedEntity &Entity, 789 InitListExpr *IList, QualType DeclType, 790 unsigned &Index, 791 InitListExpr *StructuredList, 792 unsigned &StructuredIndex) { 793 if (Index < IList->getNumInits()) { 794 Expr *expr = IList->getInit(Index); 795 if (isa<InitListExpr>(expr)) { 796 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 797 << DeclType << IList->getSourceRange(); 798 hadError = true; 799 ++Index; 800 ++StructuredIndex; 801 return; 802 } 803 804 ExprResult Result = 805 SemaRef.PerformCopyInitialization(Entity, expr->getLocStart(), 806 SemaRef.Owned(expr)); 807 808 if (Result.isInvalid()) 809 hadError = true; 810 811 expr = Result.takeAs<Expr>(); 812 IList->setInit(Index, expr); 813 814 if (hadError) 815 ++StructuredIndex; 816 else 817 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 818 ++Index; 819 } else { 820 // FIXME: It would be wonderful if we could point at the actual member. In 821 // general, it would be useful to pass location information down the stack, 822 // so that we know the location (or decl) of the "current object" being 823 // initialized. 824 SemaRef.Diag(IList->getLocStart(), 825 diag::err_init_reference_member_uninitialized) 826 << DeclType 827 << IList->getSourceRange(); 828 hadError = true; 829 ++Index; 830 ++StructuredIndex; 831 return; 832 } 833} 834 835void InitListChecker::CheckVectorType(const InitializedEntity &Entity, 836 InitListExpr *IList, QualType DeclType, 837 unsigned &Index, 838 InitListExpr *StructuredList, 839 unsigned &StructuredIndex) { 840 if (Index >= IList->getNumInits()) 841 return; 842 843 const VectorType *VT = DeclType->getAs<VectorType>(); 844 unsigned maxElements = VT->getNumElements(); 845 unsigned numEltsInit = 0; 846 QualType elementType = VT->getElementType(); 847 848 if (!SemaRef.getLangOptions().OpenCL) { 849 // If the initializing element is a vector, try to copy-initialize 850 // instead of breaking it apart (which is doomed to failure anyway). 851 Expr *Init = IList->getInit(Index); 852 if (!isa<InitListExpr>(Init) && Init->getType()->isVectorType()) { 853 ExprResult Result = 854 SemaRef.PerformCopyInitialization(Entity, Init->getLocStart(), 855 SemaRef.Owned(Init)); 856 857 Expr *ResultExpr = 0; 858 if (Result.isInvalid()) 859 hadError = true; // types weren't compatible. 860 else { 861 ResultExpr = Result.takeAs<Expr>(); 862 863 if (ResultExpr != Init) { 864 // The type was promoted, update initializer list. 865 IList->setInit(Index, ResultExpr); 866 } 867 } 868 if (hadError) 869 ++StructuredIndex; 870 else 871 UpdateStructuredListElement(StructuredList, StructuredIndex, ResultExpr); 872 ++Index; 873 return; 874 } 875 876 InitializedEntity ElementEntity = 877 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 878 879 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) { 880 // Don't attempt to go past the end of the init list 881 if (Index >= IList->getNumInits()) 882 break; 883 884 ElementEntity.setElementIndex(Index); 885 CheckSubElementType(ElementEntity, IList, elementType, Index, 886 StructuredList, StructuredIndex); 887 } 888 return; 889 } 890 891 InitializedEntity ElementEntity = 892 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 893 894 // OpenCL initializers allows vectors to be constructed from vectors. 895 for (unsigned i = 0; i < maxElements; ++i) { 896 // Don't attempt to go past the end of the init list 897 if (Index >= IList->getNumInits()) 898 break; 899 900 ElementEntity.setElementIndex(Index); 901 902 QualType IType = IList->getInit(Index)->getType(); 903 if (!IType->isVectorType()) { 904 CheckSubElementType(ElementEntity, IList, elementType, Index, 905 StructuredList, StructuredIndex); 906 ++numEltsInit; 907 } else { 908 QualType VecType; 909 const VectorType *IVT = IType->getAs<VectorType>(); 910 unsigned numIElts = IVT->getNumElements(); 911 912 if (IType->isExtVectorType()) 913 VecType = SemaRef.Context.getExtVectorType(elementType, numIElts); 914 else 915 VecType = SemaRef.Context.getVectorType(elementType, numIElts, 916 IVT->getVectorKind()); 917 CheckSubElementType(ElementEntity, IList, VecType, Index, 918 StructuredList, StructuredIndex); 919 numEltsInit += numIElts; 920 } 921 } 922 923 // OpenCL requires all elements to be initialized. 924 if (numEltsInit != maxElements) 925 if (SemaRef.getLangOptions().OpenCL) 926 SemaRef.Diag(IList->getSourceRange().getBegin(), 927 diag::err_vector_incorrect_num_initializers) 928 << (numEltsInit < maxElements) << maxElements << numEltsInit; 929} 930 931void InitListChecker::CheckArrayType(const InitializedEntity &Entity, 932 InitListExpr *IList, QualType &DeclType, 933 llvm::APSInt elementIndex, 934 bool SubobjectIsDesignatorContext, 935 unsigned &Index, 936 InitListExpr *StructuredList, 937 unsigned &StructuredIndex) { 938 // Check for the special-case of initializing an array with a string. 939 if (Index < IList->getNumInits()) { 940 if (Expr *Str = IsStringInit(IList->getInit(Index), DeclType, 941 SemaRef.Context)) { 942 CheckStringInit(Str, DeclType, SemaRef); 943 // We place the string literal directly into the resulting 944 // initializer list. This is the only place where the structure 945 // of the structured initializer list doesn't match exactly, 946 // because doing so would involve allocating one character 947 // constant for each string. 948 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 949 StructuredList->resizeInits(SemaRef.Context, StructuredIndex); 950 ++Index; 951 return; 952 } 953 } 954 if (const VariableArrayType *VAT = 955 SemaRef.Context.getAsVariableArrayType(DeclType)) { 956 // Check for VLAs; in standard C it would be possible to check this 957 // earlier, but I don't know where clang accepts VLAs (gcc accepts 958 // them in all sorts of strange places). 959 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(), 960 diag::err_variable_object_no_init) 961 << VAT->getSizeExpr()->getSourceRange(); 962 hadError = true; 963 ++Index; 964 ++StructuredIndex; 965 return; 966 } 967 968 // We might know the maximum number of elements in advance. 969 llvm::APSInt maxElements(elementIndex.getBitWidth(), 970 elementIndex.isUnsigned()); 971 bool maxElementsKnown = false; 972 if (const ConstantArrayType *CAT = 973 SemaRef.Context.getAsConstantArrayType(DeclType)) { 974 maxElements = CAT->getSize(); 975 elementIndex = elementIndex.extOrTrunc(maxElements.getBitWidth()); 976 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 977 maxElementsKnown = true; 978 } 979 980 QualType elementType = SemaRef.Context.getAsArrayType(DeclType) 981 ->getElementType(); 982 while (Index < IList->getNumInits()) { 983 Expr *Init = IList->getInit(Index); 984 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 985 // If we're not the subobject that matches up with the '{' for 986 // the designator, we shouldn't be handling the 987 // designator. Return immediately. 988 if (!SubobjectIsDesignatorContext) 989 return; 990 991 // Handle this designated initializer. elementIndex will be 992 // updated to be the next array element we'll initialize. 993 if (CheckDesignatedInitializer(Entity, IList, DIE, 0, 994 DeclType, 0, &elementIndex, Index, 995 StructuredList, StructuredIndex, true, 996 false)) { 997 hadError = true; 998 continue; 999 } 1000 1001 if (elementIndex.getBitWidth() > maxElements.getBitWidth()) 1002 maxElements = maxElements.extend(elementIndex.getBitWidth()); 1003 else if (elementIndex.getBitWidth() < maxElements.getBitWidth()) 1004 elementIndex = elementIndex.extend(maxElements.getBitWidth()); 1005 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 1006 1007 // If the array is of incomplete type, keep track of the number of 1008 // elements in the initializer. 1009 if (!maxElementsKnown && elementIndex > maxElements) 1010 maxElements = elementIndex; 1011 1012 continue; 1013 } 1014 1015 // If we know the maximum number of elements, and we've already 1016 // hit it, stop consuming elements in the initializer list. 1017 if (maxElementsKnown && elementIndex == maxElements) 1018 break; 1019 1020 InitializedEntity ElementEntity = 1021 InitializedEntity::InitializeElement(SemaRef.Context, StructuredIndex, 1022 Entity); 1023 // Check this element. 1024 CheckSubElementType(ElementEntity, IList, elementType, Index, 1025 StructuredList, StructuredIndex); 1026 ++elementIndex; 1027 1028 // If the array is of incomplete type, keep track of the number of 1029 // elements in the initializer. 1030 if (!maxElementsKnown && elementIndex > maxElements) 1031 maxElements = elementIndex; 1032 } 1033 if (!hadError && DeclType->isIncompleteArrayType()) { 1034 // If this is an incomplete array type, the actual type needs to 1035 // be calculated here. 1036 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned()); 1037 if (maxElements == Zero) { 1038 // Sizing an array implicitly to zero is not allowed by ISO C, 1039 // but is supported by GNU. 1040 SemaRef.Diag(IList->getLocStart(), 1041 diag::ext_typecheck_zero_array_size); 1042 } 1043 1044 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements, 1045 ArrayType::Normal, 0); 1046 } 1047} 1048 1049void InitListChecker::CheckStructUnionTypes(const InitializedEntity &Entity, 1050 InitListExpr *IList, 1051 QualType DeclType, 1052 RecordDecl::field_iterator Field, 1053 bool SubobjectIsDesignatorContext, 1054 unsigned &Index, 1055 InitListExpr *StructuredList, 1056 unsigned &StructuredIndex, 1057 bool TopLevelObject) { 1058 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl(); 1059 1060 // If the record is invalid, some of it's members are invalid. To avoid 1061 // confusion, we forgo checking the intializer for the entire record. 1062 if (structDecl->isInvalidDecl()) { 1063 hadError = true; 1064 return; 1065 } 1066 1067 if (DeclType->isUnionType() && IList->getNumInits() == 0) { 1068 // Value-initialize the first named member of the union. 1069 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1070 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 1071 Field != FieldEnd; ++Field) { 1072 if (Field->getDeclName()) { 1073 StructuredList->setInitializedFieldInUnion(*Field); 1074 break; 1075 } 1076 } 1077 return; 1078 } 1079 1080 // If structDecl is a forward declaration, this loop won't do 1081 // anything except look at designated initializers; That's okay, 1082 // because an error should get printed out elsewhere. It might be 1083 // worthwhile to skip over the rest of the initializer, though. 1084 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1085 RecordDecl::field_iterator FieldEnd = RD->field_end(); 1086 bool InitializedSomething = false; 1087 bool CheckForMissingFields = true; 1088 while (Index < IList->getNumInits()) { 1089 Expr *Init = IList->getInit(Index); 1090 1091 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1092 // If we're not the subobject that matches up with the '{' for 1093 // the designator, we shouldn't be handling the 1094 // designator. Return immediately. 1095 if (!SubobjectIsDesignatorContext) 1096 return; 1097 1098 // Handle this designated initializer. Field will be updated to 1099 // the next field that we'll be initializing. 1100 if (CheckDesignatedInitializer(Entity, IList, DIE, 0, 1101 DeclType, &Field, 0, Index, 1102 StructuredList, StructuredIndex, 1103 true, TopLevelObject)) 1104 hadError = true; 1105 1106 InitializedSomething = true; 1107 1108 // Disable check for missing fields when designators are used. 1109 // This matches gcc behaviour. 1110 CheckForMissingFields = false; 1111 continue; 1112 } 1113 1114 if (Field == FieldEnd) { 1115 // We've run out of fields. We're done. 1116 break; 1117 } 1118 1119 // We've already initialized a member of a union. We're done. 1120 if (InitializedSomething && DeclType->isUnionType()) 1121 break; 1122 1123 // If we've hit the flexible array member at the end, we're done. 1124 if (Field->getType()->isIncompleteArrayType()) 1125 break; 1126 1127 if (Field->isUnnamedBitfield()) { 1128 // Don't initialize unnamed bitfields, e.g. "int : 20;" 1129 ++Field; 1130 continue; 1131 } 1132 1133 InitializedEntity MemberEntity = 1134 InitializedEntity::InitializeMember(*Field, &Entity); 1135 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1136 StructuredList, StructuredIndex); 1137 InitializedSomething = true; 1138 1139 if (DeclType->isUnionType()) { 1140 // Initialize the first field within the union. 1141 StructuredList->setInitializedFieldInUnion(*Field); 1142 } 1143 1144 ++Field; 1145 } 1146 1147 // Emit warnings for missing struct field initializers. 1148 if (InitializedSomething && CheckForMissingFields && Field != FieldEnd && 1149 !Field->getType()->isIncompleteArrayType() && !DeclType->isUnionType()) { 1150 // It is possible we have one or more unnamed bitfields remaining. 1151 // Find first (if any) named field and emit warning. 1152 for (RecordDecl::field_iterator it = Field, end = RD->field_end(); 1153 it != end; ++it) { 1154 if (!it->isUnnamedBitfield()) { 1155 SemaRef.Diag(IList->getSourceRange().getEnd(), 1156 diag::warn_missing_field_initializers) << it->getName(); 1157 break; 1158 } 1159 } 1160 } 1161 1162 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() || 1163 Index >= IList->getNumInits()) 1164 return; 1165 1166 // Handle GNU flexible array initializers. 1167 if (!TopLevelObject && 1168 (!isa<InitListExpr>(IList->getInit(Index)) || 1169 cast<InitListExpr>(IList->getInit(Index))->getNumInits() > 0)) { 1170 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1171 diag::err_flexible_array_init_nonempty) 1172 << IList->getInit(Index)->getSourceRange().getBegin(); 1173 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1174 << *Field; 1175 hadError = true; 1176 ++Index; 1177 return; 1178 } else { 1179 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1180 diag::ext_flexible_array_init) 1181 << IList->getInit(Index)->getSourceRange().getBegin(); 1182 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1183 << *Field; 1184 } 1185 1186 InitializedEntity MemberEntity = 1187 InitializedEntity::InitializeMember(*Field, &Entity); 1188 1189 if (isa<InitListExpr>(IList->getInit(Index))) 1190 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1191 StructuredList, StructuredIndex); 1192 else 1193 CheckImplicitInitList(MemberEntity, IList, Field->getType(), Index, 1194 StructuredList, StructuredIndex); 1195} 1196 1197/// \brief Expand a field designator that refers to a member of an 1198/// anonymous struct or union into a series of field designators that 1199/// refers to the field within the appropriate subobject. 1200/// 1201static void ExpandAnonymousFieldDesignator(Sema &SemaRef, 1202 DesignatedInitExpr *DIE, 1203 unsigned DesigIdx, 1204 IndirectFieldDecl *IndirectField) { 1205 typedef DesignatedInitExpr::Designator Designator; 1206 1207 // Build the replacement designators. 1208 llvm::SmallVector<Designator, 4> Replacements; 1209 for (IndirectFieldDecl::chain_iterator PI = IndirectField->chain_begin(), 1210 PE = IndirectField->chain_end(); PI != PE; ++PI) { 1211 if (PI + 1 == PE) 1212 Replacements.push_back(Designator((IdentifierInfo *)0, 1213 DIE->getDesignator(DesigIdx)->getDotLoc(), 1214 DIE->getDesignator(DesigIdx)->getFieldLoc())); 1215 else 1216 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(), 1217 SourceLocation())); 1218 assert(isa<FieldDecl>(*PI)); 1219 Replacements.back().setField(cast<FieldDecl>(*PI)); 1220 } 1221 1222 // Expand the current designator into the set of replacement 1223 // designators, so we have a full subobject path down to where the 1224 // member of the anonymous struct/union is actually stored. 1225 DIE->ExpandDesignator(SemaRef.Context, DesigIdx, &Replacements[0], 1226 &Replacements[0] + Replacements.size()); 1227} 1228 1229/// \brief Given an implicit anonymous field, search the IndirectField that 1230/// corresponds to FieldName. 1231static IndirectFieldDecl *FindIndirectFieldDesignator(FieldDecl *AnonField, 1232 IdentifierInfo *FieldName) { 1233 assert(AnonField->isAnonymousStructOrUnion()); 1234 Decl *NextDecl = AnonField->getNextDeclInContext(); 1235 while (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(NextDecl)) { 1236 if (FieldName && FieldName == IF->getAnonField()->getIdentifier()) 1237 return IF; 1238 NextDecl = NextDecl->getNextDeclInContext(); 1239 } 1240 return 0; 1241} 1242 1243/// @brief Check the well-formedness of a C99 designated initializer. 1244/// 1245/// Determines whether the designated initializer @p DIE, which 1246/// resides at the given @p Index within the initializer list @p 1247/// IList, is well-formed for a current object of type @p DeclType 1248/// (C99 6.7.8). The actual subobject that this designator refers to 1249/// within the current subobject is returned in either 1250/// @p NextField or @p NextElementIndex (whichever is appropriate). 1251/// 1252/// @param IList The initializer list in which this designated 1253/// initializer occurs. 1254/// 1255/// @param DIE The designated initializer expression. 1256/// 1257/// @param DesigIdx The index of the current designator. 1258/// 1259/// @param DeclType The type of the "current object" (C99 6.7.8p17), 1260/// into which the designation in @p DIE should refer. 1261/// 1262/// @param NextField If non-NULL and the first designator in @p DIE is 1263/// a field, this will be set to the field declaration corresponding 1264/// to the field named by the designator. 1265/// 1266/// @param NextElementIndex If non-NULL and the first designator in @p 1267/// DIE is an array designator or GNU array-range designator, this 1268/// will be set to the last index initialized by this designator. 1269/// 1270/// @param Index Index into @p IList where the designated initializer 1271/// @p DIE occurs. 1272/// 1273/// @param StructuredList The initializer list expression that 1274/// describes all of the subobject initializers in the order they'll 1275/// actually be initialized. 1276/// 1277/// @returns true if there was an error, false otherwise. 1278bool 1279InitListChecker::CheckDesignatedInitializer(const InitializedEntity &Entity, 1280 InitListExpr *IList, 1281 DesignatedInitExpr *DIE, 1282 unsigned DesigIdx, 1283 QualType &CurrentObjectType, 1284 RecordDecl::field_iterator *NextField, 1285 llvm::APSInt *NextElementIndex, 1286 unsigned &Index, 1287 InitListExpr *StructuredList, 1288 unsigned &StructuredIndex, 1289 bool FinishSubobjectInit, 1290 bool TopLevelObject) { 1291 if (DesigIdx == DIE->size()) { 1292 // Check the actual initialization for the designated object type. 1293 bool prevHadError = hadError; 1294 1295 // Temporarily remove the designator expression from the 1296 // initializer list that the child calls see, so that we don't try 1297 // to re-process the designator. 1298 unsigned OldIndex = Index; 1299 IList->setInit(OldIndex, DIE->getInit()); 1300 1301 CheckSubElementType(Entity, IList, CurrentObjectType, Index, 1302 StructuredList, StructuredIndex); 1303 1304 // Restore the designated initializer expression in the syntactic 1305 // form of the initializer list. 1306 if (IList->getInit(OldIndex) != DIE->getInit()) 1307 DIE->setInit(IList->getInit(OldIndex)); 1308 IList->setInit(OldIndex, DIE); 1309 1310 return hadError && !prevHadError; 1311 } 1312 1313 bool IsFirstDesignator = (DesigIdx == 0); 1314 assert((IsFirstDesignator || StructuredList) && 1315 "Need a non-designated initializer list to start from"); 1316 1317 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx); 1318 // Determine the structural initializer list that corresponds to the 1319 // current subobject. 1320 StructuredList = IsFirstDesignator? SyntacticToSemantic[IList] 1321 : getStructuredSubobjectInit(IList, Index, CurrentObjectType, 1322 StructuredList, StructuredIndex, 1323 SourceRange(D->getStartLocation(), 1324 DIE->getSourceRange().getEnd())); 1325 assert(StructuredList && "Expected a structured initializer list"); 1326 1327 if (D->isFieldDesignator()) { 1328 // C99 6.7.8p7: 1329 // 1330 // If a designator has the form 1331 // 1332 // . identifier 1333 // 1334 // then the current object (defined below) shall have 1335 // structure or union type and the identifier shall be the 1336 // name of a member of that type. 1337 const RecordType *RT = CurrentObjectType->getAs<RecordType>(); 1338 if (!RT) { 1339 SourceLocation Loc = D->getDotLoc(); 1340 if (Loc.isInvalid()) 1341 Loc = D->getFieldLoc(); 1342 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr) 1343 << SemaRef.getLangOptions().CPlusPlus << CurrentObjectType; 1344 ++Index; 1345 return true; 1346 } 1347 1348 // Note: we perform a linear search of the fields here, despite 1349 // the fact that we have a faster lookup method, because we always 1350 // need to compute the field's index. 1351 FieldDecl *KnownField = D->getField(); 1352 IdentifierInfo *FieldName = D->getFieldName(); 1353 unsigned FieldIndex = 0; 1354 RecordDecl::field_iterator 1355 Field = RT->getDecl()->field_begin(), 1356 FieldEnd = RT->getDecl()->field_end(); 1357 for (; Field != FieldEnd; ++Field) { 1358 if (Field->isUnnamedBitfield()) 1359 continue; 1360 1361 // If we find a field representing an anonymous field, look in the 1362 // IndirectFieldDecl that follow for the designated initializer. 1363 if (!KnownField && Field->isAnonymousStructOrUnion()) { 1364 if (IndirectFieldDecl *IF = 1365 FindIndirectFieldDesignator(*Field, FieldName)) { 1366 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IF); 1367 D = DIE->getDesignator(DesigIdx); 1368 break; 1369 } 1370 } 1371 if (KnownField && KnownField == *Field) 1372 break; 1373 if (FieldName && FieldName == Field->getIdentifier()) 1374 break; 1375 1376 ++FieldIndex; 1377 } 1378 1379 if (Field == FieldEnd) { 1380 // There was no normal field in the struct with the designated 1381 // name. Perform another lookup for this name, which may find 1382 // something that we can't designate (e.g., a member function), 1383 // may find nothing, or may find a member of an anonymous 1384 // struct/union. 1385 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName); 1386 FieldDecl *ReplacementField = 0; 1387 if (Lookup.first == Lookup.second) { 1388 // Name lookup didn't find anything. Determine whether this 1389 // was a typo for another field name. 1390 LookupResult R(SemaRef, FieldName, D->getFieldLoc(), 1391 Sema::LookupMemberName); 1392 if (SemaRef.CorrectTypo(R, /*Scope=*/0, /*SS=*/0, RT->getDecl(), false, 1393 Sema::CTC_NoKeywords) && 1394 (ReplacementField = R.getAsSingle<FieldDecl>()) && 1395 ReplacementField->getDeclContext()->getRedeclContext() 1396 ->Equals(RT->getDecl())) { 1397 SemaRef.Diag(D->getFieldLoc(), 1398 diag::err_field_designator_unknown_suggest) 1399 << FieldName << CurrentObjectType << R.getLookupName() 1400 << FixItHint::CreateReplacement(D->getFieldLoc(), 1401 R.getLookupName().getAsString()); 1402 SemaRef.Diag(ReplacementField->getLocation(), 1403 diag::note_previous_decl) 1404 << ReplacementField->getDeclName(); 1405 } else { 1406 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown) 1407 << FieldName << CurrentObjectType; 1408 ++Index; 1409 return true; 1410 } 1411 } 1412 1413 if (!ReplacementField) { 1414 // Name lookup found something, but it wasn't a field. 1415 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield) 1416 << FieldName; 1417 SemaRef.Diag((*Lookup.first)->getLocation(), 1418 diag::note_field_designator_found); 1419 ++Index; 1420 return true; 1421 } 1422 1423 if (!KnownField) { 1424 // The replacement field comes from typo correction; find it 1425 // in the list of fields. 1426 FieldIndex = 0; 1427 Field = RT->getDecl()->field_begin(); 1428 for (; Field != FieldEnd; ++Field) { 1429 if (Field->isUnnamedBitfield()) 1430 continue; 1431 1432 if (ReplacementField == *Field || 1433 Field->getIdentifier() == ReplacementField->getIdentifier()) 1434 break; 1435 1436 ++FieldIndex; 1437 } 1438 } 1439 } 1440 1441 // All of the fields of a union are located at the same place in 1442 // the initializer list. 1443 if (RT->getDecl()->isUnion()) { 1444 FieldIndex = 0; 1445 StructuredList->setInitializedFieldInUnion(*Field); 1446 } 1447 1448 // Update the designator with the field declaration. 1449 D->setField(*Field); 1450 1451 // Make sure that our non-designated initializer list has space 1452 // for a subobject corresponding to this field. 1453 if (FieldIndex >= StructuredList->getNumInits()) 1454 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1); 1455 1456 // This designator names a flexible array member. 1457 if (Field->getType()->isIncompleteArrayType()) { 1458 bool Invalid = false; 1459 if ((DesigIdx + 1) != DIE->size()) { 1460 // We can't designate an object within the flexible array 1461 // member (because GCC doesn't allow it). 1462 DesignatedInitExpr::Designator *NextD 1463 = DIE->getDesignator(DesigIdx + 1); 1464 SemaRef.Diag(NextD->getStartLocation(), 1465 diag::err_designator_into_flexible_array_member) 1466 << SourceRange(NextD->getStartLocation(), 1467 DIE->getSourceRange().getEnd()); 1468 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1469 << *Field; 1470 Invalid = true; 1471 } 1472 1473 if (!hadError && !isa<InitListExpr>(DIE->getInit()) && 1474 !isa<StringLiteral>(DIE->getInit())) { 1475 // The initializer is not an initializer list. 1476 SemaRef.Diag(DIE->getInit()->getSourceRange().getBegin(), 1477 diag::err_flexible_array_init_needs_braces) 1478 << DIE->getInit()->getSourceRange(); 1479 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1480 << *Field; 1481 Invalid = true; 1482 } 1483 1484 // Handle GNU flexible array initializers. 1485 if (!Invalid && !TopLevelObject && 1486 cast<InitListExpr>(DIE->getInit())->getNumInits() > 0) { 1487 SemaRef.Diag(DIE->getSourceRange().getBegin(), 1488 diag::err_flexible_array_init_nonempty) 1489 << DIE->getSourceRange().getBegin(); 1490 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1491 << *Field; 1492 Invalid = true; 1493 } 1494 1495 if (Invalid) { 1496 ++Index; 1497 return true; 1498 } 1499 1500 // Initialize the array. 1501 bool prevHadError = hadError; 1502 unsigned newStructuredIndex = FieldIndex; 1503 unsigned OldIndex = Index; 1504 IList->setInit(Index, DIE->getInit()); 1505 1506 InitializedEntity MemberEntity = 1507 InitializedEntity::InitializeMember(*Field, &Entity); 1508 CheckSubElementType(MemberEntity, IList, Field->getType(), Index, 1509 StructuredList, newStructuredIndex); 1510 1511 IList->setInit(OldIndex, DIE); 1512 if (hadError && !prevHadError) { 1513 ++Field; 1514 ++FieldIndex; 1515 if (NextField) 1516 *NextField = Field; 1517 StructuredIndex = FieldIndex; 1518 return true; 1519 } 1520 } else { 1521 // Recurse to check later designated subobjects. 1522 QualType FieldType = (*Field)->getType(); 1523 unsigned newStructuredIndex = FieldIndex; 1524 1525 InitializedEntity MemberEntity = 1526 InitializedEntity::InitializeMember(*Field, &Entity); 1527 if (CheckDesignatedInitializer(MemberEntity, IList, DIE, DesigIdx + 1, 1528 FieldType, 0, 0, Index, 1529 StructuredList, newStructuredIndex, 1530 true, false)) 1531 return true; 1532 } 1533 1534 // Find the position of the next field to be initialized in this 1535 // subobject. 1536 ++Field; 1537 ++FieldIndex; 1538 1539 // If this the first designator, our caller will continue checking 1540 // the rest of this struct/class/union subobject. 1541 if (IsFirstDesignator) { 1542 if (NextField) 1543 *NextField = Field; 1544 StructuredIndex = FieldIndex; 1545 return false; 1546 } 1547 1548 if (!FinishSubobjectInit) 1549 return false; 1550 1551 // We've already initialized something in the union; we're done. 1552 if (RT->getDecl()->isUnion()) 1553 return hadError; 1554 1555 // Check the remaining fields within this class/struct/union subobject. 1556 bool prevHadError = hadError; 1557 1558 CheckStructUnionTypes(Entity, IList, CurrentObjectType, Field, false, Index, 1559 StructuredList, FieldIndex); 1560 return hadError && !prevHadError; 1561 } 1562 1563 // C99 6.7.8p6: 1564 // 1565 // If a designator has the form 1566 // 1567 // [ constant-expression ] 1568 // 1569 // then the current object (defined below) shall have array 1570 // type and the expression shall be an integer constant 1571 // expression. If the array is of unknown size, any 1572 // nonnegative value is valid. 1573 // 1574 // Additionally, cope with the GNU extension that permits 1575 // designators of the form 1576 // 1577 // [ constant-expression ... constant-expression ] 1578 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType); 1579 if (!AT) { 1580 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) 1581 << CurrentObjectType; 1582 ++Index; 1583 return true; 1584 } 1585 1586 Expr *IndexExpr = 0; 1587 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex; 1588 if (D->isArrayDesignator()) { 1589 IndexExpr = DIE->getArrayIndex(*D); 1590 DesignatedStartIndex = IndexExpr->EvaluateAsInt(SemaRef.Context); 1591 DesignatedEndIndex = DesignatedStartIndex; 1592 } else { 1593 assert(D->isArrayRangeDesignator() && "Need array-range designator"); 1594 1595 1596 DesignatedStartIndex = 1597 DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context); 1598 DesignatedEndIndex = 1599 DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context); 1600 IndexExpr = DIE->getArrayRangeEnd(*D); 1601 1602 if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue()) 1603 FullyStructuredList->sawArrayRangeDesignator(); 1604 } 1605 1606 if (isa<ConstantArrayType>(AT)) { 1607 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false); 1608 DesignatedStartIndex 1609 = DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth()); 1610 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned()); 1611 DesignatedEndIndex 1612 = DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth()); 1613 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned()); 1614 if (DesignatedEndIndex >= MaxElements) { 1615 SemaRef.Diag(IndexExpr->getSourceRange().getBegin(), 1616 diag::err_array_designator_too_large) 1617 << DesignatedEndIndex.toString(10) << MaxElements.toString(10) 1618 << IndexExpr->getSourceRange(); 1619 ++Index; 1620 return true; 1621 } 1622 } else { 1623 // Make sure the bit-widths and signedness match. 1624 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth()) 1625 DesignatedEndIndex 1626 = DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth()); 1627 else if (DesignatedStartIndex.getBitWidth() < 1628 DesignatedEndIndex.getBitWidth()) 1629 DesignatedStartIndex 1630 = DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth()); 1631 DesignatedStartIndex.setIsUnsigned(true); 1632 DesignatedEndIndex.setIsUnsigned(true); 1633 } 1634 1635 // Make sure that our non-designated initializer list has space 1636 // for a subobject corresponding to this array element. 1637 if (DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits()) 1638 StructuredList->resizeInits(SemaRef.Context, 1639 DesignatedEndIndex.getZExtValue() + 1); 1640 1641 // Repeatedly perform subobject initializations in the range 1642 // [DesignatedStartIndex, DesignatedEndIndex]. 1643 1644 // Move to the next designator 1645 unsigned ElementIndex = DesignatedStartIndex.getZExtValue(); 1646 unsigned OldIndex = Index; 1647 1648 InitializedEntity ElementEntity = 1649 InitializedEntity::InitializeElement(SemaRef.Context, 0, Entity); 1650 1651 while (DesignatedStartIndex <= DesignatedEndIndex) { 1652 // Recurse to check later designated subobjects. 1653 QualType ElementType = AT->getElementType(); 1654 Index = OldIndex; 1655 1656 ElementEntity.setElementIndex(ElementIndex); 1657 if (CheckDesignatedInitializer(ElementEntity, IList, DIE, DesigIdx + 1, 1658 ElementType, 0, 0, Index, 1659 StructuredList, ElementIndex, 1660 (DesignatedStartIndex == DesignatedEndIndex), 1661 false)) 1662 return true; 1663 1664 // Move to the next index in the array that we'll be initializing. 1665 ++DesignatedStartIndex; 1666 ElementIndex = DesignatedStartIndex.getZExtValue(); 1667 } 1668 1669 // If this the first designator, our caller will continue checking 1670 // the rest of this array subobject. 1671 if (IsFirstDesignator) { 1672 if (NextElementIndex) 1673 *NextElementIndex = DesignatedStartIndex; 1674 StructuredIndex = ElementIndex; 1675 return false; 1676 } 1677 1678 if (!FinishSubobjectInit) 1679 return false; 1680 1681 // Check the remaining elements within this array subobject. 1682 bool prevHadError = hadError; 1683 CheckArrayType(Entity, IList, CurrentObjectType, DesignatedStartIndex, 1684 /*SubobjectIsDesignatorContext=*/false, Index, 1685 StructuredList, ElementIndex); 1686 return hadError && !prevHadError; 1687} 1688 1689// Get the structured initializer list for a subobject of type 1690// @p CurrentObjectType. 1691InitListExpr * 1692InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 1693 QualType CurrentObjectType, 1694 InitListExpr *StructuredList, 1695 unsigned StructuredIndex, 1696 SourceRange InitRange) { 1697 Expr *ExistingInit = 0; 1698 if (!StructuredList) 1699 ExistingInit = SyntacticToSemantic[IList]; 1700 else if (StructuredIndex < StructuredList->getNumInits()) 1701 ExistingInit = StructuredList->getInit(StructuredIndex); 1702 1703 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) 1704 return Result; 1705 1706 if (ExistingInit) { 1707 // We are creating an initializer list that initializes the 1708 // subobjects of the current object, but there was already an 1709 // initialization that completely initialized the current 1710 // subobject, e.g., by a compound literal: 1711 // 1712 // struct X { int a, b; }; 1713 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 1714 // 1715 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 1716 // designated initializer re-initializes the whole 1717 // subobject [0], overwriting previous initializers. 1718 SemaRef.Diag(InitRange.getBegin(), 1719 diag::warn_subobject_initializer_overrides) 1720 << InitRange; 1721 SemaRef.Diag(ExistingInit->getSourceRange().getBegin(), 1722 diag::note_previous_initializer) 1723 << /*FIXME:has side effects=*/0 1724 << ExistingInit->getSourceRange(); 1725 } 1726 1727 InitListExpr *Result 1728 = new (SemaRef.Context) InitListExpr(SemaRef.Context, 1729 InitRange.getBegin(), 0, 0, 1730 InitRange.getEnd()); 1731 1732 Result->setType(CurrentObjectType.getNonLValueExprType(SemaRef.Context)); 1733 1734 // Pre-allocate storage for the structured initializer list. 1735 unsigned NumElements = 0; 1736 unsigned NumInits = 0; 1737 if (!StructuredList) 1738 NumInits = IList->getNumInits(); 1739 else if (Index < IList->getNumInits()) { 1740 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) 1741 NumInits = SubList->getNumInits(); 1742 } 1743 1744 if (const ArrayType *AType 1745 = SemaRef.Context.getAsArrayType(CurrentObjectType)) { 1746 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) { 1747 NumElements = CAType->getSize().getZExtValue(); 1748 // Simple heuristic so that we don't allocate a very large 1749 // initializer with many empty entries at the end. 1750 if (NumInits && NumElements > NumInits) 1751 NumElements = 0; 1752 } 1753 } else if (const VectorType *VType = CurrentObjectType->getAs<VectorType>()) 1754 NumElements = VType->getNumElements(); 1755 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) { 1756 RecordDecl *RDecl = RType->getDecl(); 1757 if (RDecl->isUnion()) 1758 NumElements = 1; 1759 else 1760 NumElements = std::distance(RDecl->field_begin(), 1761 RDecl->field_end()); 1762 } 1763 1764 if (NumElements < NumInits) 1765 NumElements = IList->getNumInits(); 1766 1767 Result->reserveInits(SemaRef.Context, NumElements); 1768 1769 // Link this new initializer list into the structured initializer 1770 // lists. 1771 if (StructuredList) 1772 StructuredList->updateInit(SemaRef.Context, StructuredIndex, Result); 1773 else { 1774 Result->setSyntacticForm(IList); 1775 SyntacticToSemantic[IList] = Result; 1776 } 1777 1778 return Result; 1779} 1780 1781/// Update the initializer at index @p StructuredIndex within the 1782/// structured initializer list to the value @p expr. 1783void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, 1784 unsigned &StructuredIndex, 1785 Expr *expr) { 1786 // No structured initializer list to update 1787 if (!StructuredList) 1788 return; 1789 1790 if (Expr *PrevInit = StructuredList->updateInit(SemaRef.Context, 1791 StructuredIndex, expr)) { 1792 // This initializer overwrites a previous initializer. Warn. 1793 SemaRef.Diag(expr->getSourceRange().getBegin(), 1794 diag::warn_initializer_overrides) 1795 << expr->getSourceRange(); 1796 SemaRef.Diag(PrevInit->getSourceRange().getBegin(), 1797 diag::note_previous_initializer) 1798 << /*FIXME:has side effects=*/0 1799 << PrevInit->getSourceRange(); 1800 } 1801 1802 ++StructuredIndex; 1803} 1804 1805/// Check that the given Index expression is a valid array designator 1806/// value. This is essentailly just a wrapper around 1807/// VerifyIntegerConstantExpression that also checks for negative values 1808/// and produces a reasonable diagnostic if there is a 1809/// failure. Returns true if there was an error, false otherwise. If 1810/// everything went okay, Value will receive the value of the constant 1811/// expression. 1812static bool 1813CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) { 1814 SourceLocation Loc = Index->getSourceRange().getBegin(); 1815 1816 // Make sure this is an integer constant expression. 1817 if (S.VerifyIntegerConstantExpression(Index, &Value)) 1818 return true; 1819 1820 if (Value.isSigned() && Value.isNegative()) 1821 return S.Diag(Loc, diag::err_array_designator_negative) 1822 << Value.toString(10) << Index->getSourceRange(); 1823 1824 Value.setIsUnsigned(true); 1825 return false; 1826} 1827 1828ExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, 1829 SourceLocation Loc, 1830 bool GNUSyntax, 1831 ExprResult Init) { 1832 typedef DesignatedInitExpr::Designator ASTDesignator; 1833 1834 bool Invalid = false; 1835 llvm::SmallVector<ASTDesignator, 32> Designators; 1836 llvm::SmallVector<Expr *, 32> InitExpressions; 1837 1838 // Build designators and check array designator expressions. 1839 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { 1840 const Designator &D = Desig.getDesignator(Idx); 1841 switch (D.getKind()) { 1842 case Designator::FieldDesignator: 1843 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), 1844 D.getFieldLoc())); 1845 break; 1846 1847 case Designator::ArrayDesignator: { 1848 Expr *Index = static_cast<Expr *>(D.getArrayIndex()); 1849 llvm::APSInt IndexValue; 1850 if (!Index->isTypeDependent() && 1851 !Index->isValueDependent() && 1852 CheckArrayDesignatorExpr(*this, Index, IndexValue)) 1853 Invalid = true; 1854 else { 1855 Designators.push_back(ASTDesignator(InitExpressions.size(), 1856 D.getLBracketLoc(), 1857 D.getRBracketLoc())); 1858 InitExpressions.push_back(Index); 1859 } 1860 break; 1861 } 1862 1863 case Designator::ArrayRangeDesignator: { 1864 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); 1865 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); 1866 llvm::APSInt StartValue; 1867 llvm::APSInt EndValue; 1868 bool StartDependent = StartIndex->isTypeDependent() || 1869 StartIndex->isValueDependent(); 1870 bool EndDependent = EndIndex->isTypeDependent() || 1871 EndIndex->isValueDependent(); 1872 if ((!StartDependent && 1873 CheckArrayDesignatorExpr(*this, StartIndex, StartValue)) || 1874 (!EndDependent && 1875 CheckArrayDesignatorExpr(*this, EndIndex, EndValue))) 1876 Invalid = true; 1877 else { 1878 // Make sure we're comparing values with the same bit width. 1879 if (StartDependent || EndDependent) { 1880 // Nothing to compute. 1881 } else if (StartValue.getBitWidth() > EndValue.getBitWidth()) 1882 EndValue = EndValue.extend(StartValue.getBitWidth()); 1883 else if (StartValue.getBitWidth() < EndValue.getBitWidth()) 1884 StartValue = StartValue.extend(EndValue.getBitWidth()); 1885 1886 if (!StartDependent && !EndDependent && EndValue < StartValue) { 1887 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) 1888 << StartValue.toString(10) << EndValue.toString(10) 1889 << StartIndex->getSourceRange() << EndIndex->getSourceRange(); 1890 Invalid = true; 1891 } else { 1892 Designators.push_back(ASTDesignator(InitExpressions.size(), 1893 D.getLBracketLoc(), 1894 D.getEllipsisLoc(), 1895 D.getRBracketLoc())); 1896 InitExpressions.push_back(StartIndex); 1897 InitExpressions.push_back(EndIndex); 1898 } 1899 } 1900 break; 1901 } 1902 } 1903 } 1904 1905 if (Invalid || Init.isInvalid()) 1906 return ExprError(); 1907 1908 // Clear out the expressions within the designation. 1909 Desig.ClearExprs(*this); 1910 1911 DesignatedInitExpr *DIE 1912 = DesignatedInitExpr::Create(Context, 1913 Designators.data(), Designators.size(), 1914 InitExpressions.data(), InitExpressions.size(), 1915 Loc, GNUSyntax, Init.takeAs<Expr>()); 1916 1917 if (getLangOptions().CPlusPlus) 1918 Diag(DIE->getLocStart(), diag::ext_designated_init) 1919 << DIE->getSourceRange(); 1920 1921 return Owned(DIE); 1922} 1923 1924bool Sema::CheckInitList(const InitializedEntity &Entity, 1925 InitListExpr *&InitList, QualType &DeclType) { 1926 InitListChecker CheckInitList(*this, Entity, InitList, DeclType); 1927 if (!CheckInitList.HadError()) 1928 InitList = CheckInitList.getFullyStructuredList(); 1929 1930 return CheckInitList.HadError(); 1931} 1932 1933//===----------------------------------------------------------------------===// 1934// Initialization entity 1935//===----------------------------------------------------------------------===// 1936 1937InitializedEntity::InitializedEntity(ASTContext &Context, unsigned Index, 1938 const InitializedEntity &Parent) 1939 : Parent(&Parent), Index(Index) 1940{ 1941 if (const ArrayType *AT = Context.getAsArrayType(Parent.getType())) { 1942 Kind = EK_ArrayElement; 1943 Type = AT->getElementType(); 1944 } else { 1945 Kind = EK_VectorElement; 1946 Type = Parent.getType()->getAs<VectorType>()->getElementType(); 1947 } 1948} 1949 1950InitializedEntity InitializedEntity::InitializeBase(ASTContext &Context, 1951 CXXBaseSpecifier *Base, 1952 bool IsInheritedVirtualBase) 1953{ 1954 InitializedEntity Result; 1955 Result.Kind = EK_Base; 1956 Result.Base = reinterpret_cast<uintptr_t>(Base); 1957 if (IsInheritedVirtualBase) 1958 Result.Base |= 0x01; 1959 1960 Result.Type = Base->getType(); 1961 return Result; 1962} 1963 1964DeclarationName InitializedEntity::getName() const { 1965 switch (getKind()) { 1966 case EK_Parameter: 1967 if (!VariableOrMember) 1968 return DeclarationName(); 1969 // Fall through 1970 1971 case EK_Variable: 1972 case EK_Member: 1973 return VariableOrMember->getDeclName(); 1974 1975 case EK_Result: 1976 case EK_Exception: 1977 case EK_New: 1978 case EK_Temporary: 1979 case EK_Base: 1980 case EK_ArrayElement: 1981 case EK_VectorElement: 1982 case EK_BlockElement: 1983 return DeclarationName(); 1984 } 1985 1986 // Silence GCC warning 1987 return DeclarationName(); 1988} 1989 1990DeclaratorDecl *InitializedEntity::getDecl() const { 1991 switch (getKind()) { 1992 case EK_Variable: 1993 case EK_Parameter: 1994 case EK_Member: 1995 return VariableOrMember; 1996 1997 case EK_Result: 1998 case EK_Exception: 1999 case EK_New: 2000 case EK_Temporary: 2001 case EK_Base: 2002 case EK_ArrayElement: 2003 case EK_VectorElement: 2004 case EK_BlockElement: 2005 return 0; 2006 } 2007 2008 // Silence GCC warning 2009 return 0; 2010} 2011 2012bool InitializedEntity::allowsNRVO() const { 2013 switch (getKind()) { 2014 case EK_Result: 2015 case EK_Exception: 2016 return LocAndNRVO.NRVO; 2017 2018 case EK_Variable: 2019 case EK_Parameter: 2020 case EK_Member: 2021 case EK_New: 2022 case EK_Temporary: 2023 case EK_Base: 2024 case EK_ArrayElement: 2025 case EK_VectorElement: 2026 case EK_BlockElement: 2027 break; 2028 } 2029 2030 return false; 2031} 2032 2033//===----------------------------------------------------------------------===// 2034// Initialization sequence 2035//===----------------------------------------------------------------------===// 2036 2037void InitializationSequence::Step::Destroy() { 2038 switch (Kind) { 2039 case SK_ResolveAddressOfOverloadedFunction: 2040 case SK_CastDerivedToBaseRValue: 2041 case SK_CastDerivedToBaseXValue: 2042 case SK_CastDerivedToBaseLValue: 2043 case SK_BindReference: 2044 case SK_BindReferenceToTemporary: 2045 case SK_ExtraneousCopyToTemporary: 2046 case SK_UserConversion: 2047 case SK_QualificationConversionRValue: 2048 case SK_QualificationConversionXValue: 2049 case SK_QualificationConversionLValue: 2050 case SK_ListInitialization: 2051 case SK_ConstructorInitialization: 2052 case SK_ZeroInitialization: 2053 case SK_CAssignment: 2054 case SK_StringInit: 2055 case SK_ObjCObjectConversion: 2056 break; 2057 2058 case SK_ConversionSequence: 2059 delete ICS; 2060 } 2061} 2062 2063bool InitializationSequence::isDirectReferenceBinding() const { 2064 return getKind() == ReferenceBinding && Steps.back().Kind == SK_BindReference; 2065} 2066 2067bool InitializationSequence::isAmbiguous() const { 2068 if (getKind() != FailedSequence) 2069 return false; 2070 2071 switch (getFailureKind()) { 2072 case FK_TooManyInitsForReference: 2073 case FK_ArrayNeedsInitList: 2074 case FK_ArrayNeedsInitListOrStringLiteral: 2075 case FK_AddressOfOverloadFailed: // FIXME: Could do better 2076 case FK_NonConstLValueReferenceBindingToTemporary: 2077 case FK_NonConstLValueReferenceBindingToUnrelated: 2078 case FK_RValueReferenceBindingToLValue: 2079 case FK_ReferenceInitDropsQualifiers: 2080 case FK_ReferenceInitFailed: 2081 case FK_ConversionFailed: 2082 case FK_TooManyInitsForScalar: 2083 case FK_ReferenceBindingToInitList: 2084 case FK_InitListBadDestinationType: 2085 case FK_DefaultInitOfConst: 2086 case FK_Incomplete: 2087 return false; 2088 2089 case FK_ReferenceInitOverloadFailed: 2090 case FK_UserConversionOverloadFailed: 2091 case FK_ConstructorOverloadFailed: 2092 return FailedOverloadResult == OR_Ambiguous; 2093 } 2094 2095 return false; 2096} 2097 2098bool InitializationSequence::isConstructorInitialization() const { 2099 return !Steps.empty() && Steps.back().Kind == SK_ConstructorInitialization; 2100} 2101 2102void InitializationSequence::AddAddressOverloadResolutionStep( 2103 FunctionDecl *Function, 2104 DeclAccessPair Found) { 2105 Step S; 2106 S.Kind = SK_ResolveAddressOfOverloadedFunction; 2107 S.Type = Function->getType(); 2108 S.Function.Function = Function; 2109 S.Function.FoundDecl = Found; 2110 Steps.push_back(S); 2111} 2112 2113void InitializationSequence::AddDerivedToBaseCastStep(QualType BaseType, 2114 ExprValueKind VK) { 2115 Step S; 2116 switch (VK) { 2117 case VK_RValue: S.Kind = SK_CastDerivedToBaseRValue; break; 2118 case VK_XValue: S.Kind = SK_CastDerivedToBaseXValue; break; 2119 case VK_LValue: S.Kind = SK_CastDerivedToBaseLValue; break; 2120 default: llvm_unreachable("No such category"); 2121 } 2122 S.Type = BaseType; 2123 Steps.push_back(S); 2124} 2125 2126void InitializationSequence::AddReferenceBindingStep(QualType T, 2127 bool BindingTemporary) { 2128 Step S; 2129 S.Kind = BindingTemporary? SK_BindReferenceToTemporary : SK_BindReference; 2130 S.Type = T; 2131 Steps.push_back(S); 2132} 2133 2134void InitializationSequence::AddExtraneousCopyToTemporary(QualType T) { 2135 Step S; 2136 S.Kind = SK_ExtraneousCopyToTemporary; 2137 S.Type = T; 2138 Steps.push_back(S); 2139} 2140 2141void InitializationSequence::AddUserConversionStep(FunctionDecl *Function, 2142 DeclAccessPair FoundDecl, 2143 QualType T) { 2144 Step S; 2145 S.Kind = SK_UserConversion; 2146 S.Type = T; 2147 S.Function.Function = Function; 2148 S.Function.FoundDecl = FoundDecl; 2149 Steps.push_back(S); 2150} 2151 2152void InitializationSequence::AddQualificationConversionStep(QualType Ty, 2153 ExprValueKind VK) { 2154 Step S; 2155 S.Kind = SK_QualificationConversionRValue; // work around a gcc warning 2156 switch (VK) { 2157 case VK_RValue: 2158 S.Kind = SK_QualificationConversionRValue; 2159 break; 2160 case VK_XValue: 2161 S.Kind = SK_QualificationConversionXValue; 2162 break; 2163 case VK_LValue: 2164 S.Kind = SK_QualificationConversionLValue; 2165 break; 2166 } 2167 S.Type = Ty; 2168 Steps.push_back(S); 2169} 2170 2171void InitializationSequence::AddConversionSequenceStep( 2172 const ImplicitConversionSequence &ICS, 2173 QualType T) { 2174 Step S; 2175 S.Kind = SK_ConversionSequence; 2176 S.Type = T; 2177 S.ICS = new ImplicitConversionSequence(ICS); 2178 Steps.push_back(S); 2179} 2180 2181void InitializationSequence::AddListInitializationStep(QualType T) { 2182 Step S; 2183 S.Kind = SK_ListInitialization; 2184 S.Type = T; 2185 Steps.push_back(S); 2186} 2187 2188void 2189InitializationSequence::AddConstructorInitializationStep( 2190 CXXConstructorDecl *Constructor, 2191 AccessSpecifier Access, 2192 QualType T) { 2193 Step S; 2194 S.Kind = SK_ConstructorInitialization; 2195 S.Type = T; 2196 S.Function.Function = Constructor; 2197 S.Function.FoundDecl = DeclAccessPair::make(Constructor, Access); 2198 Steps.push_back(S); 2199} 2200 2201void InitializationSequence::AddZeroInitializationStep(QualType T) { 2202 Step S; 2203 S.Kind = SK_ZeroInitialization; 2204 S.Type = T; 2205 Steps.push_back(S); 2206} 2207 2208void InitializationSequence::AddCAssignmentStep(QualType T) { 2209 Step S; 2210 S.Kind = SK_CAssignment; 2211 S.Type = T; 2212 Steps.push_back(S); 2213} 2214 2215void InitializationSequence::AddStringInitStep(QualType T) { 2216 Step S; 2217 S.Kind = SK_StringInit; 2218 S.Type = T; 2219 Steps.push_back(S); 2220} 2221 2222void InitializationSequence::AddObjCObjectConversionStep(QualType T) { 2223 Step S; 2224 S.Kind = SK_ObjCObjectConversion; 2225 S.Type = T; 2226 Steps.push_back(S); 2227} 2228 2229void InitializationSequence::SetOverloadFailure(FailureKind Failure, 2230 OverloadingResult Result) { 2231 SequenceKind = FailedSequence; 2232 this->Failure = Failure; 2233 this->FailedOverloadResult = Result; 2234} 2235 2236//===----------------------------------------------------------------------===// 2237// Attempt initialization 2238//===----------------------------------------------------------------------===// 2239 2240/// \brief Attempt list initialization (C++0x [dcl.init.list]) 2241static void TryListInitialization(Sema &S, 2242 const InitializedEntity &Entity, 2243 const InitializationKind &Kind, 2244 InitListExpr *InitList, 2245 InitializationSequence &Sequence) { 2246 // FIXME: We only perform rudimentary checking of list 2247 // initializations at this point, then assume that any list 2248 // initialization of an array, aggregate, or scalar will be 2249 // well-formed. When we actually "perform" list initialization, we'll 2250 // do all of the necessary checking. C++0x initializer lists will 2251 // force us to perform more checking here. 2252 Sequence.setSequenceKind(InitializationSequence::ListInitialization); 2253 2254 QualType DestType = Entity.getType(); 2255 2256 // C++ [dcl.init]p13: 2257 // If T is a scalar type, then a declaration of the form 2258 // 2259 // T x = { a }; 2260 // 2261 // is equivalent to 2262 // 2263 // T x = a; 2264 if (DestType->isScalarType()) { 2265 if (InitList->getNumInits() > 1 && S.getLangOptions().CPlusPlus) { 2266 Sequence.SetFailed(InitializationSequence::FK_TooManyInitsForScalar); 2267 return; 2268 } 2269 2270 // Assume scalar initialization from a single value works. 2271 } else if (DestType->isAggregateType()) { 2272 // Assume aggregate initialization works. 2273 } else if (DestType->isVectorType()) { 2274 // Assume vector initialization works. 2275 } else if (DestType->isReferenceType()) { 2276 // FIXME: C++0x defines behavior for this. 2277 Sequence.SetFailed(InitializationSequence::FK_ReferenceBindingToInitList); 2278 return; 2279 } else if (DestType->isRecordType()) { 2280 // FIXME: C++0x defines behavior for this 2281 Sequence.SetFailed(InitializationSequence::FK_InitListBadDestinationType); 2282 } 2283 2284 // Add a general "list initialization" step. 2285 Sequence.AddListInitializationStep(DestType); 2286} 2287 2288/// \brief Try a reference initialization that involves calling a conversion 2289/// function. 2290static OverloadingResult TryRefInitWithConversionFunction(Sema &S, 2291 const InitializedEntity &Entity, 2292 const InitializationKind &Kind, 2293 Expr *Initializer, 2294 bool AllowRValues, 2295 InitializationSequence &Sequence) { 2296 QualType DestType = Entity.getType(); 2297 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 2298 QualType T1 = cv1T1.getUnqualifiedType(); 2299 QualType cv2T2 = Initializer->getType(); 2300 QualType T2 = cv2T2.getUnqualifiedType(); 2301 2302 bool DerivedToBase; 2303 bool ObjCConversion; 2304 assert(!S.CompareReferenceRelationship(Initializer->getLocStart(), 2305 T1, T2, DerivedToBase, 2306 ObjCConversion) && 2307 "Must have incompatible references when binding via conversion"); 2308 (void)DerivedToBase; 2309 (void)ObjCConversion; 2310 2311 // Build the candidate set directly in the initialization sequence 2312 // structure, so that it will persist if we fail. 2313 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 2314 CandidateSet.clear(); 2315 2316 // Determine whether we are allowed to call explicit constructors or 2317 // explicit conversion operators. 2318 bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct; 2319 2320 const RecordType *T1RecordType = 0; 2321 if (AllowRValues && (T1RecordType = T1->getAs<RecordType>()) && 2322 !S.RequireCompleteType(Kind.getLocation(), T1, 0)) { 2323 // The type we're converting to is a class type. Enumerate its constructors 2324 // to see if there is a suitable conversion. 2325 CXXRecordDecl *T1RecordDecl = cast<CXXRecordDecl>(T1RecordType->getDecl()); 2326 2327 DeclContext::lookup_iterator Con, ConEnd; 2328 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(T1RecordDecl); 2329 Con != ConEnd; ++Con) { 2330 NamedDecl *D = *Con; 2331 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2332 2333 // Find the constructor (which may be a template). 2334 CXXConstructorDecl *Constructor = 0; 2335 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D); 2336 if (ConstructorTmpl) 2337 Constructor = cast<CXXConstructorDecl>( 2338 ConstructorTmpl->getTemplatedDecl()); 2339 else 2340 Constructor = cast<CXXConstructorDecl>(D); 2341 2342 if (!Constructor->isInvalidDecl() && 2343 Constructor->isConvertingConstructor(AllowExplicit)) { 2344 if (ConstructorTmpl) 2345 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2346 /*ExplicitArgs*/ 0, 2347 &Initializer, 1, CandidateSet, 2348 /*SuppressUserConversions=*/true); 2349 else 2350 S.AddOverloadCandidate(Constructor, FoundDecl, 2351 &Initializer, 1, CandidateSet, 2352 /*SuppressUserConversions=*/true); 2353 } 2354 } 2355 } 2356 if (T1RecordType && T1RecordType->getDecl()->isInvalidDecl()) 2357 return OR_No_Viable_Function; 2358 2359 const RecordType *T2RecordType = 0; 2360 if ((T2RecordType = T2->getAs<RecordType>()) && 2361 !S.RequireCompleteType(Kind.getLocation(), T2, 0)) { 2362 // The type we're converting from is a class type, enumerate its conversion 2363 // functions. 2364 CXXRecordDecl *T2RecordDecl = cast<CXXRecordDecl>(T2RecordType->getDecl()); 2365 2366 const UnresolvedSetImpl *Conversions 2367 = T2RecordDecl->getVisibleConversionFunctions(); 2368 for (UnresolvedSetImpl::const_iterator I = Conversions->begin(), 2369 E = Conversions->end(); I != E; ++I) { 2370 NamedDecl *D = *I; 2371 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 2372 if (isa<UsingShadowDecl>(D)) 2373 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2374 2375 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 2376 CXXConversionDecl *Conv; 2377 if (ConvTemplate) 2378 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 2379 else 2380 Conv = cast<CXXConversionDecl>(D); 2381 2382 // If the conversion function doesn't return a reference type, 2383 // it can't be considered for this conversion unless we're allowed to 2384 // consider rvalues. 2385 // FIXME: Do we need to make sure that we only consider conversion 2386 // candidates with reference-compatible results? That might be needed to 2387 // break recursion. 2388 if ((AllowExplicit || !Conv->isExplicit()) && 2389 (AllowRValues || Conv->getConversionType()->isLValueReferenceType())){ 2390 if (ConvTemplate) 2391 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), 2392 ActingDC, Initializer, 2393 DestType, CandidateSet); 2394 else 2395 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, 2396 Initializer, DestType, CandidateSet); 2397 } 2398 } 2399 } 2400 if (T2RecordType && T2RecordType->getDecl()->isInvalidDecl()) 2401 return OR_No_Viable_Function; 2402 2403 SourceLocation DeclLoc = Initializer->getLocStart(); 2404 2405 // Perform overload resolution. If it fails, return the failed result. 2406 OverloadCandidateSet::iterator Best; 2407 if (OverloadingResult Result 2408 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) 2409 return Result; 2410 2411 FunctionDecl *Function = Best->Function; 2412 2413 // Compute the returned type of the conversion. 2414 if (isa<CXXConversionDecl>(Function)) 2415 T2 = Function->getResultType(); 2416 else 2417 T2 = cv1T1; 2418 2419 // Add the user-defined conversion step. 2420 Sequence.AddUserConversionStep(Function, Best->FoundDecl, 2421 T2.getNonLValueExprType(S.Context)); 2422 2423 // Determine whether we need to perform derived-to-base or 2424 // cv-qualification adjustments. 2425 ExprValueKind VK = VK_RValue; 2426 if (T2->isLValueReferenceType()) 2427 VK = VK_LValue; 2428 else if (const RValueReferenceType *RRef = T2->getAs<RValueReferenceType>()) 2429 VK = RRef->getPointeeType()->isFunctionType() ? VK_LValue : VK_XValue; 2430 2431 bool NewDerivedToBase = false; 2432 bool NewObjCConversion = false; 2433 Sema::ReferenceCompareResult NewRefRelationship 2434 = S.CompareReferenceRelationship(DeclLoc, T1, 2435 T2.getNonLValueExprType(S.Context), 2436 NewDerivedToBase, NewObjCConversion); 2437 if (NewRefRelationship == Sema::Ref_Incompatible) { 2438 // If the type we've converted to is not reference-related to the 2439 // type we're looking for, then there is another conversion step 2440 // we need to perform to produce a temporary of the right type 2441 // that we'll be binding to. 2442 ImplicitConversionSequence ICS; 2443 ICS.setStandard(); 2444 ICS.Standard = Best->FinalConversion; 2445 T2 = ICS.Standard.getToType(2); 2446 Sequence.AddConversionSequenceStep(ICS, T2); 2447 } else if (NewDerivedToBase) 2448 Sequence.AddDerivedToBaseCastStep( 2449 S.Context.getQualifiedType(T1, 2450 T2.getNonReferenceType().getQualifiers()), 2451 VK); 2452 else if (NewObjCConversion) 2453 Sequence.AddObjCObjectConversionStep( 2454 S.Context.getQualifiedType(T1, 2455 T2.getNonReferenceType().getQualifiers())); 2456 2457 if (cv1T1.getQualifiers() != T2.getNonReferenceType().getQualifiers()) 2458 Sequence.AddQualificationConversionStep(cv1T1, VK); 2459 2460 Sequence.AddReferenceBindingStep(cv1T1, !T2->isReferenceType()); 2461 return OR_Success; 2462} 2463 2464/// \brief Attempt reference initialization (C++0x [dcl.init.ref]) 2465static void TryReferenceInitialization(Sema &S, 2466 const InitializedEntity &Entity, 2467 const InitializationKind &Kind, 2468 Expr *Initializer, 2469 InitializationSequence &Sequence) { 2470 Sequence.setSequenceKind(InitializationSequence::ReferenceBinding); 2471 2472 QualType DestType = Entity.getType(); 2473 QualType cv1T1 = DestType->getAs<ReferenceType>()->getPointeeType(); 2474 Qualifiers T1Quals; 2475 QualType T1 = S.Context.getUnqualifiedArrayType(cv1T1, T1Quals); 2476 QualType cv2T2 = Initializer->getType(); 2477 Qualifiers T2Quals; 2478 QualType T2 = S.Context.getUnqualifiedArrayType(cv2T2, T2Quals); 2479 SourceLocation DeclLoc = Initializer->getLocStart(); 2480 2481 // If the initializer is the address of an overloaded function, try 2482 // to resolve the overloaded function. If all goes well, T2 is the 2483 // type of the resulting function. 2484 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 2485 DeclAccessPair Found; 2486 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Initializer, 2487 T1, 2488 false, 2489 Found)) { 2490 Sequence.AddAddressOverloadResolutionStep(Fn, Found); 2491 cv2T2 = Fn->getType(); 2492 T2 = cv2T2.getUnqualifiedType(); 2493 } else if (!T1->isRecordType()) { 2494 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 2495 return; 2496 } 2497 } 2498 2499 // Compute some basic properties of the types and the initializer. 2500 bool isLValueRef = DestType->isLValueReferenceType(); 2501 bool isRValueRef = !isLValueRef; 2502 bool DerivedToBase = false; 2503 bool ObjCConversion = false; 2504 Expr::Classification InitCategory = Initializer->Classify(S.Context); 2505 Sema::ReferenceCompareResult RefRelationship 2506 = S.CompareReferenceRelationship(DeclLoc, cv1T1, cv2T2, DerivedToBase, 2507 ObjCConversion); 2508 2509 // C++0x [dcl.init.ref]p5: 2510 // A reference to type "cv1 T1" is initialized by an expression of type 2511 // "cv2 T2" as follows: 2512 // 2513 // - If the reference is an lvalue reference and the initializer 2514 // expression 2515 // Note the analogous bullet points for rvlaue refs to functions. Because 2516 // there are no function rvalues in C++, rvalue refs to functions are treated 2517 // like lvalue refs. 2518 OverloadingResult ConvOvlResult = OR_Success; 2519 bool T1Function = T1->isFunctionType(); 2520 if (isLValueRef || T1Function) { 2521 if (InitCategory.isLValue() && 2522 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) { 2523 // - is an lvalue (but is not a bit-field), and "cv1 T1" is 2524 // reference-compatible with "cv2 T2," or 2525 // 2526 // Per C++ [over.best.ics]p2, we don't diagnose whether the lvalue is a 2527 // bit-field when we're determining whether the reference initialization 2528 // can occur. However, we do pay attention to whether it is a bit-field 2529 // to decide whether we're actually binding to a temporary created from 2530 // the bit-field. 2531 if (DerivedToBase) 2532 Sequence.AddDerivedToBaseCastStep( 2533 S.Context.getQualifiedType(T1, T2Quals), 2534 VK_LValue); 2535 else if (ObjCConversion) 2536 Sequence.AddObjCObjectConversionStep( 2537 S.Context.getQualifiedType(T1, T2Quals)); 2538 2539 if (T1Quals != T2Quals) 2540 Sequence.AddQualificationConversionStep(cv1T1, VK_LValue); 2541 bool BindingTemporary = T1Quals.hasConst() && !T1Quals.hasVolatile() && 2542 (Initializer->getBitField() || Initializer->refersToVectorElement()); 2543 Sequence.AddReferenceBindingStep(cv1T1, BindingTemporary); 2544 return; 2545 } 2546 2547 // - has a class type (i.e., T2 is a class type), where T1 is not 2548 // reference-related to T2, and can be implicitly converted to an 2549 // lvalue of type "cv3 T3," where "cv1 T1" is reference-compatible 2550 // with "cv3 T3" (this conversion is selected by enumerating the 2551 // applicable conversion functions (13.3.1.6) and choosing the best 2552 // one through overload resolution (13.3)), 2553 // If we have an rvalue ref to function type here, the rhs must be 2554 // an rvalue. 2555 if (RefRelationship == Sema::Ref_Incompatible && T2->isRecordType() && 2556 (isLValueRef || InitCategory.isRValue())) { 2557 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, Kind, 2558 Initializer, 2559 /*AllowRValues=*/isRValueRef, 2560 Sequence); 2561 if (ConvOvlResult == OR_Success) 2562 return; 2563 if (ConvOvlResult != OR_No_Viable_Function) { 2564 Sequence.SetOverloadFailure( 2565 InitializationSequence::FK_ReferenceInitOverloadFailed, 2566 ConvOvlResult); 2567 } 2568 } 2569 } 2570 2571 // - Otherwise, the reference shall be an lvalue reference to a 2572 // non-volatile const type (i.e., cv1 shall be const), or the reference 2573 // shall be an rvalue reference. 2574 if (isLValueRef && !(T1Quals.hasConst() && !T1Quals.hasVolatile())) { 2575 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 2576 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 2577 else if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 2578 Sequence.SetOverloadFailure( 2579 InitializationSequence::FK_ReferenceInitOverloadFailed, 2580 ConvOvlResult); 2581 else 2582 Sequence.SetFailed(InitCategory.isLValue() 2583 ? (RefRelationship == Sema::Ref_Related 2584 ? InitializationSequence::FK_ReferenceInitDropsQualifiers 2585 : InitializationSequence::FK_NonConstLValueReferenceBindingToUnrelated) 2586 : InitializationSequence::FK_NonConstLValueReferenceBindingToTemporary); 2587 2588 return; 2589 } 2590 2591 // - If the initializer expression 2592 // - is an xvalue, class prvalue, array prvalue, or function lvalue and 2593 // "cv1 T1" is reference-compatible with "cv2 T2" 2594 // Note: functions are handled below. 2595 if (!T1Function && 2596 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification && 2597 (InitCategory.isXValue() || 2598 (InitCategory.isPRValue() && T2->isRecordType()) || 2599 (InitCategory.isPRValue() && T2->isArrayType()))) { 2600 ExprValueKind ValueKind = InitCategory.isXValue()? VK_XValue : VK_RValue; 2601 if (InitCategory.isPRValue() && T2->isRecordType()) { 2602 // The corresponding bullet in C++03 [dcl.init.ref]p5 gives the 2603 // compiler the freedom to perform a copy here or bind to the 2604 // object, while C++0x requires that we bind directly to the 2605 // object. Hence, we always bind to the object without making an 2606 // extra copy. However, in C++03 requires that we check for the 2607 // presence of a suitable copy constructor: 2608 // 2609 // The constructor that would be used to make the copy shall 2610 // be callable whether or not the copy is actually done. 2611 if (!S.getLangOptions().CPlusPlus0x && !S.getLangOptions().Microsoft) 2612 Sequence.AddExtraneousCopyToTemporary(cv2T2); 2613 } 2614 2615 if (DerivedToBase) 2616 Sequence.AddDerivedToBaseCastStep(S.Context.getQualifiedType(T1, T2Quals), 2617 ValueKind); 2618 else if (ObjCConversion) 2619 Sequence.AddObjCObjectConversionStep( 2620 S.Context.getQualifiedType(T1, T2Quals)); 2621 2622 if (T1Quals != T2Quals) 2623 Sequence.AddQualificationConversionStep(cv1T1, ValueKind); 2624 Sequence.AddReferenceBindingStep(cv1T1, 2625 /*bindingTemporary=*/(InitCategory.isPRValue() && !T2->isArrayType())); 2626 return; 2627 } 2628 2629 // - has a class type (i.e., T2 is a class type), where T1 is not 2630 // reference-related to T2, and can be implicitly converted to an 2631 // xvalue, class prvalue, or function lvalue of type "cv3 T3", 2632 // where "cv1 T1" is reference-compatible with "cv3 T3", 2633 // 2634 // FIXME: Need to handle xvalue, class prvalue, etc. cases in 2635 // TryRefInitWithConversionFunction. 2636 if (T2->isRecordType()) { 2637 if (RefRelationship == Sema::Ref_Incompatible) { 2638 ConvOvlResult = TryRefInitWithConversionFunction(S, Entity, 2639 Kind, Initializer, 2640 /*AllowRValues=*/true, 2641 Sequence); 2642 if (ConvOvlResult) 2643 Sequence.SetOverloadFailure( 2644 InitializationSequence::FK_ReferenceInitOverloadFailed, 2645 ConvOvlResult); 2646 2647 return; 2648 } 2649 2650 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 2651 return; 2652 } 2653 2654 // - Otherwise, a temporary of type “cv1 T1” is created and initialized 2655 // from the initializer expression using the rules for a non-reference 2656 // copy initialization (8.5). The reference is then bound to the 2657 // temporary. [...] 2658 2659 // Determine whether we are allowed to call explicit constructors or 2660 // explicit conversion operators. 2661 bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct); 2662 2663 InitializedEntity TempEntity = InitializedEntity::InitializeTemporary(cv1T1); 2664 2665 if (S.TryImplicitConversion(Sequence, TempEntity, Initializer, 2666 /*SuppressUserConversions*/ false, 2667 AllowExplicit, 2668 /*FIXME:InOverloadResolution=*/false)) { 2669 // FIXME: Use the conversion function set stored in ICS to turn 2670 // this into an overloading ambiguity diagnostic. However, we need 2671 // to keep that set as an OverloadCandidateSet rather than as some 2672 // other kind of set. 2673 if (ConvOvlResult && !Sequence.getFailedCandidateSet().empty()) 2674 Sequence.SetOverloadFailure( 2675 InitializationSequence::FK_ReferenceInitOverloadFailed, 2676 ConvOvlResult); 2677 else if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) 2678 Sequence.SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 2679 else 2680 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitFailed); 2681 return; 2682 } 2683 2684 // [...] If T1 is reference-related to T2, cv1 must be the 2685 // same cv-qualification as, or greater cv-qualification 2686 // than, cv2; otherwise, the program is ill-formed. 2687 unsigned T1CVRQuals = T1Quals.getCVRQualifiers(); 2688 unsigned T2CVRQuals = T2Quals.getCVRQualifiers(); 2689 if (RefRelationship == Sema::Ref_Related && 2690 (T1CVRQuals | T2CVRQuals) != T1CVRQuals) { 2691 Sequence.SetFailed(InitializationSequence::FK_ReferenceInitDropsQualifiers); 2692 return; 2693 } 2694 2695 // [...] If T1 is reference-related to T2 and the reference is an rvalue 2696 // reference, the initializer expression shall not be an lvalue. 2697 if (RefRelationship >= Sema::Ref_Related && !isLValueRef && 2698 InitCategory.isLValue()) { 2699 Sequence.SetFailed( 2700 InitializationSequence::FK_RValueReferenceBindingToLValue); 2701 return; 2702 } 2703 2704 Sequence.AddReferenceBindingStep(cv1T1, /*bindingTemporary=*/true); 2705 return; 2706} 2707 2708/// \brief Attempt character array initialization from a string literal 2709/// (C++ [dcl.init.string], C99 6.7.8). 2710static void TryStringLiteralInitialization(Sema &S, 2711 const InitializedEntity &Entity, 2712 const InitializationKind &Kind, 2713 Expr *Initializer, 2714 InitializationSequence &Sequence) { 2715 Sequence.setSequenceKind(InitializationSequence::StringInit); 2716 Sequence.AddStringInitStep(Entity.getType()); 2717} 2718 2719/// \brief Attempt initialization by constructor (C++ [dcl.init]), which 2720/// enumerates the constructors of the initialized entity and performs overload 2721/// resolution to select the best. 2722static void TryConstructorInitialization(Sema &S, 2723 const InitializedEntity &Entity, 2724 const InitializationKind &Kind, 2725 Expr **Args, unsigned NumArgs, 2726 QualType DestType, 2727 InitializationSequence &Sequence) { 2728 Sequence.setSequenceKind(InitializationSequence::ConstructorInitialization); 2729 2730 // Build the candidate set directly in the initialization sequence 2731 // structure, so that it will persist if we fail. 2732 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 2733 CandidateSet.clear(); 2734 2735 // Determine whether we are allowed to call explicit constructors or 2736 // explicit conversion operators. 2737 bool AllowExplicit = (Kind.getKind() == InitializationKind::IK_Direct || 2738 Kind.getKind() == InitializationKind::IK_Value || 2739 Kind.getKind() == InitializationKind::IK_Default); 2740 2741 // The type we're constructing needs to be complete. 2742 if (S.RequireCompleteType(Kind.getLocation(), DestType, 0)) { 2743 Sequence.SetFailed(InitializationSequence::FK_Incomplete); 2744 return; 2745 } 2746 2747 // The type we're converting to is a class type. Enumerate its constructors 2748 // to see if one is suitable. 2749 const RecordType *DestRecordType = DestType->getAs<RecordType>(); 2750 assert(DestRecordType && "Constructor initialization requires record type"); 2751 CXXRecordDecl *DestRecordDecl 2752 = cast<CXXRecordDecl>(DestRecordType->getDecl()); 2753 2754 DeclContext::lookup_iterator Con, ConEnd; 2755 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(DestRecordDecl); 2756 Con != ConEnd; ++Con) { 2757 NamedDecl *D = *Con; 2758 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2759 bool SuppressUserConversions = false; 2760 2761 // Find the constructor (which may be a template). 2762 CXXConstructorDecl *Constructor = 0; 2763 FunctionTemplateDecl *ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D); 2764 if (ConstructorTmpl) 2765 Constructor = cast<CXXConstructorDecl>( 2766 ConstructorTmpl->getTemplatedDecl()); 2767 else { 2768 Constructor = cast<CXXConstructorDecl>(D); 2769 2770 // If we're performing copy initialization using a copy constructor, we 2771 // suppress user-defined conversions on the arguments. 2772 // FIXME: Move constructors? 2773 if (Kind.getKind() == InitializationKind::IK_Copy && 2774 Constructor->isCopyConstructor()) 2775 SuppressUserConversions = true; 2776 } 2777 2778 if (!Constructor->isInvalidDecl() && 2779 (AllowExplicit || !Constructor->isExplicit())) { 2780 if (ConstructorTmpl) 2781 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2782 /*ExplicitArgs*/ 0, 2783 Args, NumArgs, CandidateSet, 2784 SuppressUserConversions); 2785 else 2786 S.AddOverloadCandidate(Constructor, FoundDecl, 2787 Args, NumArgs, CandidateSet, 2788 SuppressUserConversions); 2789 } 2790 } 2791 2792 SourceLocation DeclLoc = Kind.getLocation(); 2793 2794 // Perform overload resolution. If it fails, return the failed result. 2795 OverloadCandidateSet::iterator Best; 2796 if (OverloadingResult Result 2797 = CandidateSet.BestViableFunction(S, DeclLoc, Best)) { 2798 Sequence.SetOverloadFailure( 2799 InitializationSequence::FK_ConstructorOverloadFailed, 2800 Result); 2801 return; 2802 } 2803 2804 // C++0x [dcl.init]p6: 2805 // If a program calls for the default initialization of an object 2806 // of a const-qualified type T, T shall be a class type with a 2807 // user-provided default constructor. 2808 if (Kind.getKind() == InitializationKind::IK_Default && 2809 Entity.getType().isConstQualified() && 2810 cast<CXXConstructorDecl>(Best->Function)->isImplicit()) { 2811 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst); 2812 return; 2813 } 2814 2815 // Add the constructor initialization step. Any cv-qualification conversion is 2816 // subsumed by the initialization. 2817 Sequence.AddConstructorInitializationStep( 2818 cast<CXXConstructorDecl>(Best->Function), 2819 Best->FoundDecl.getAccess(), 2820 DestType); 2821} 2822 2823/// \brief Attempt value initialization (C++ [dcl.init]p7). 2824static void TryValueInitialization(Sema &S, 2825 const InitializedEntity &Entity, 2826 const InitializationKind &Kind, 2827 InitializationSequence &Sequence) { 2828 // C++ [dcl.init]p5: 2829 // 2830 // To value-initialize an object of type T means: 2831 QualType T = Entity.getType(); 2832 2833 // -- if T is an array type, then each element is value-initialized; 2834 while (const ArrayType *AT = S.Context.getAsArrayType(T)) 2835 T = AT->getElementType(); 2836 2837 if (const RecordType *RT = T->getAs<RecordType>()) { 2838 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 2839 // -- if T is a class type (clause 9) with a user-declared 2840 // constructor (12.1), then the default constructor for T is 2841 // called (and the initialization is ill-formed if T has no 2842 // accessible default constructor); 2843 // 2844 // FIXME: we really want to refer to a single subobject of the array, 2845 // but Entity doesn't have a way to capture that (yet). 2846 if (ClassDecl->hasUserDeclaredConstructor()) 2847 return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence); 2848 2849 // -- if T is a (possibly cv-qualified) non-union class type 2850 // without a user-provided constructor, then the object is 2851 // zero-initialized and, if T’s implicitly-declared default 2852 // constructor is non-trivial, that constructor is called. 2853 if ((ClassDecl->getTagKind() == TTK_Class || 2854 ClassDecl->getTagKind() == TTK_Struct)) { 2855 Sequence.AddZeroInitializationStep(Entity.getType()); 2856 return TryConstructorInitialization(S, Entity, Kind, 0, 0, T, Sequence); 2857 } 2858 } 2859 } 2860 2861 Sequence.AddZeroInitializationStep(Entity.getType()); 2862 Sequence.setSequenceKind(InitializationSequence::ZeroInitialization); 2863} 2864 2865/// \brief Attempt default initialization (C++ [dcl.init]p6). 2866static void TryDefaultInitialization(Sema &S, 2867 const InitializedEntity &Entity, 2868 const InitializationKind &Kind, 2869 InitializationSequence &Sequence) { 2870 assert(Kind.getKind() == InitializationKind::IK_Default); 2871 2872 // C++ [dcl.init]p6: 2873 // To default-initialize an object of type T means: 2874 // - if T is an array type, each element is default-initialized; 2875 QualType DestType = Entity.getType(); 2876 while (const ArrayType *Array = S.Context.getAsArrayType(DestType)) 2877 DestType = Array->getElementType(); 2878 2879 // - if T is a (possibly cv-qualified) class type (Clause 9), the default 2880 // constructor for T is called (and the initialization is ill-formed if 2881 // T has no accessible default constructor); 2882 if (DestType->isRecordType() && S.getLangOptions().CPlusPlus) { 2883 TryConstructorInitialization(S, Entity, Kind, 0, 0, DestType, Sequence); 2884 return; 2885 } 2886 2887 // - otherwise, no initialization is performed. 2888 Sequence.setSequenceKind(InitializationSequence::NoInitialization); 2889 2890 // If a program calls for the default initialization of an object of 2891 // a const-qualified type T, T shall be a class type with a user-provided 2892 // default constructor. 2893 if (DestType.isConstQualified() && S.getLangOptions().CPlusPlus) 2894 Sequence.SetFailed(InitializationSequence::FK_DefaultInitOfConst); 2895} 2896 2897/// \brief Attempt a user-defined conversion between two types (C++ [dcl.init]), 2898/// which enumerates all conversion functions and performs overload resolution 2899/// to select the best. 2900static void TryUserDefinedConversion(Sema &S, 2901 const InitializedEntity &Entity, 2902 const InitializationKind &Kind, 2903 Expr *Initializer, 2904 InitializationSequence &Sequence) { 2905 Sequence.setSequenceKind(InitializationSequence::UserDefinedConversion); 2906 2907 QualType DestType = Entity.getType(); 2908 assert(!DestType->isReferenceType() && "References are handled elsewhere"); 2909 QualType SourceType = Initializer->getType(); 2910 assert((DestType->isRecordType() || SourceType->isRecordType()) && 2911 "Must have a class type to perform a user-defined conversion"); 2912 2913 // Build the candidate set directly in the initialization sequence 2914 // structure, so that it will persist if we fail. 2915 OverloadCandidateSet &CandidateSet = Sequence.getFailedCandidateSet(); 2916 CandidateSet.clear(); 2917 2918 // Determine whether we are allowed to call explicit constructors or 2919 // explicit conversion operators. 2920 bool AllowExplicit = Kind.getKind() == InitializationKind::IK_Direct; 2921 2922 if (const RecordType *DestRecordType = DestType->getAs<RecordType>()) { 2923 // The type we're converting to is a class type. Enumerate its constructors 2924 // to see if there is a suitable conversion. 2925 CXXRecordDecl *DestRecordDecl 2926 = cast<CXXRecordDecl>(DestRecordType->getDecl()); 2927 2928 // Try to complete the type we're converting to. 2929 if (!S.RequireCompleteType(Kind.getLocation(), DestType, 0)) { 2930 DeclContext::lookup_iterator Con, ConEnd; 2931 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(DestRecordDecl); 2932 Con != ConEnd; ++Con) { 2933 NamedDecl *D = *Con; 2934 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2935 2936 // Find the constructor (which may be a template). 2937 CXXConstructorDecl *Constructor = 0; 2938 FunctionTemplateDecl *ConstructorTmpl 2939 = dyn_cast<FunctionTemplateDecl>(D); 2940 if (ConstructorTmpl) 2941 Constructor = cast<CXXConstructorDecl>( 2942 ConstructorTmpl->getTemplatedDecl()); 2943 else 2944 Constructor = cast<CXXConstructorDecl>(D); 2945 2946 if (!Constructor->isInvalidDecl() && 2947 Constructor->isConvertingConstructor(AllowExplicit)) { 2948 if (ConstructorTmpl) 2949 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2950 /*ExplicitArgs*/ 0, 2951 &Initializer, 1, CandidateSet, 2952 /*SuppressUserConversions=*/true); 2953 else 2954 S.AddOverloadCandidate(Constructor, FoundDecl, 2955 &Initializer, 1, CandidateSet, 2956 /*SuppressUserConversions=*/true); 2957 } 2958 } 2959 } 2960 } 2961 2962 SourceLocation DeclLoc = Initializer->getLocStart(); 2963 2964 if (const RecordType *SourceRecordType = SourceType->getAs<RecordType>()) { 2965 // The type we're converting from is a class type, enumerate its conversion 2966 // functions. 2967 2968 // We can only enumerate the conversion functions for a complete type; if 2969 // the type isn't complete, simply skip this step. 2970 if (!S.RequireCompleteType(DeclLoc, SourceType, 0)) { 2971 CXXRecordDecl *SourceRecordDecl 2972 = cast<CXXRecordDecl>(SourceRecordType->getDecl()); 2973 2974 const UnresolvedSetImpl *Conversions 2975 = SourceRecordDecl->getVisibleConversionFunctions(); 2976 for (UnresolvedSetImpl::const_iterator I = Conversions->begin(), 2977 E = Conversions->end(); 2978 I != E; ++I) { 2979 NamedDecl *D = *I; 2980 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 2981 if (isa<UsingShadowDecl>(D)) 2982 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2983 2984 FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D); 2985 CXXConversionDecl *Conv; 2986 if (ConvTemplate) 2987 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 2988 else 2989 Conv = cast<CXXConversionDecl>(D); 2990 2991 if (AllowExplicit || !Conv->isExplicit()) { 2992 if (ConvTemplate) 2993 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), 2994 ActingDC, Initializer, DestType, 2995 CandidateSet); 2996 else 2997 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, 2998 Initializer, DestType, CandidateSet); 2999 } 3000 } 3001 } 3002 } 3003 3004 // Perform overload resolution. If it fails, return the failed result. 3005 OverloadCandidateSet::iterator Best; 3006 if (OverloadingResult Result 3007 = CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) { 3008 Sequence.SetOverloadFailure( 3009 InitializationSequence::FK_UserConversionOverloadFailed, 3010 Result); 3011 return; 3012 } 3013 3014 FunctionDecl *Function = Best->Function; 3015 3016 if (isa<CXXConstructorDecl>(Function)) { 3017 // Add the user-defined conversion step. Any cv-qualification conversion is 3018 // subsumed by the initialization. 3019 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType); 3020 return; 3021 } 3022 3023 // Add the user-defined conversion step that calls the conversion function. 3024 QualType ConvType = Function->getCallResultType(); 3025 if (ConvType->getAs<RecordType>()) { 3026 // If we're converting to a class type, there may be an copy if 3027 // the resulting temporary object (possible to create an object of 3028 // a base class type). That copy is not a separate conversion, so 3029 // we just make a note of the actual destination type (possibly a 3030 // base class of the type returned by the conversion function) and 3031 // let the user-defined conversion step handle the conversion. 3032 Sequence.AddUserConversionStep(Function, Best->FoundDecl, DestType); 3033 return; 3034 } 3035 3036 Sequence.AddUserConversionStep(Function, Best->FoundDecl, ConvType); 3037 3038 // If the conversion following the call to the conversion function 3039 // is interesting, add it as a separate step. 3040 if (Best->FinalConversion.First || Best->FinalConversion.Second || 3041 Best->FinalConversion.Third) { 3042 ImplicitConversionSequence ICS; 3043 ICS.setStandard(); 3044 ICS.Standard = Best->FinalConversion; 3045 Sequence.AddConversionSequenceStep(ICS, DestType); 3046 } 3047} 3048 3049InitializationSequence::InitializationSequence(Sema &S, 3050 const InitializedEntity &Entity, 3051 const InitializationKind &Kind, 3052 Expr **Args, 3053 unsigned NumArgs) 3054 : FailedCandidateSet(Kind.getLocation()) { 3055 ASTContext &Context = S.Context; 3056 3057 // C++0x [dcl.init]p16: 3058 // The semantics of initializers are as follows. The destination type is 3059 // the type of the object or reference being initialized and the source 3060 // type is the type of the initializer expression. The source type is not 3061 // defined when the initializer is a braced-init-list or when it is a 3062 // parenthesized list of expressions. 3063 QualType DestType = Entity.getType(); 3064 3065 if (DestType->isDependentType() || 3066 Expr::hasAnyTypeDependentArguments(Args, NumArgs)) { 3067 SequenceKind = DependentSequence; 3068 return; 3069 } 3070 3071 for (unsigned I = 0; I != NumArgs; ++I) 3072 if (Args[I]->getObjectKind() == OK_ObjCProperty) 3073 S.ConvertPropertyForRValue(Args[I]); 3074 3075 QualType SourceType; 3076 Expr *Initializer = 0; 3077 if (NumArgs == 1) { 3078 Initializer = Args[0]; 3079 if (!isa<InitListExpr>(Initializer)) 3080 SourceType = Initializer->getType(); 3081 } 3082 3083 // - If the initializer is a braced-init-list, the object is 3084 // list-initialized (8.5.4). 3085 if (InitListExpr *InitList = dyn_cast_or_null<InitListExpr>(Initializer)) { 3086 TryListInitialization(S, Entity, Kind, InitList, *this); 3087 return; 3088 } 3089 3090 // - If the destination type is a reference type, see 8.5.3. 3091 if (DestType->isReferenceType()) { 3092 // C++0x [dcl.init.ref]p1: 3093 // A variable declared to be a T& or T&&, that is, "reference to type T" 3094 // (8.3.2), shall be initialized by an object, or function, of type T or 3095 // by an object that can be converted into a T. 3096 // (Therefore, multiple arguments are not permitted.) 3097 if (NumArgs != 1) 3098 SetFailed(FK_TooManyInitsForReference); 3099 else 3100 TryReferenceInitialization(S, Entity, Kind, Args[0], *this); 3101 return; 3102 } 3103 3104 // - If the destination type is an array of characters, an array of 3105 // char16_t, an array of char32_t, or an array of wchar_t, and the 3106 // initializer is a string literal, see 8.5.2. 3107 if (Initializer && IsStringInit(Initializer, DestType, Context)) { 3108 TryStringLiteralInitialization(S, Entity, Kind, Initializer, *this); 3109 return; 3110 } 3111 3112 // - If the initializer is (), the object is value-initialized. 3113 if (Kind.getKind() == InitializationKind::IK_Value || 3114 (Kind.getKind() == InitializationKind::IK_Direct && NumArgs == 0)) { 3115 TryValueInitialization(S, Entity, Kind, *this); 3116 return; 3117 } 3118 3119 // Handle default initialization. 3120 if (Kind.getKind() == InitializationKind::IK_Default) { 3121 TryDefaultInitialization(S, Entity, Kind, *this); 3122 return; 3123 } 3124 3125 // - Otherwise, if the destination type is an array, the program is 3126 // ill-formed. 3127 if (const ArrayType *AT = Context.getAsArrayType(DestType)) { 3128 if (AT->getElementType()->isAnyCharacterType()) 3129 SetFailed(FK_ArrayNeedsInitListOrStringLiteral); 3130 else 3131 SetFailed(FK_ArrayNeedsInitList); 3132 3133 return; 3134 } 3135 3136 // Handle initialization in C 3137 if (!S.getLangOptions().CPlusPlus) { 3138 setSequenceKind(CAssignment); 3139 AddCAssignmentStep(DestType); 3140 return; 3141 } 3142 3143 // - If the destination type is a (possibly cv-qualified) class type: 3144 if (DestType->isRecordType()) { 3145 // - If the initialization is direct-initialization, or if it is 3146 // copy-initialization where the cv-unqualified version of the 3147 // source type is the same class as, or a derived class of, the 3148 // class of the destination, constructors are considered. [...] 3149 if (Kind.getKind() == InitializationKind::IK_Direct || 3150 (Kind.getKind() == InitializationKind::IK_Copy && 3151 (Context.hasSameUnqualifiedType(SourceType, DestType) || 3152 S.IsDerivedFrom(SourceType, DestType)))) 3153 TryConstructorInitialization(S, Entity, Kind, Args, NumArgs, 3154 Entity.getType(), *this); 3155 // - Otherwise (i.e., for the remaining copy-initialization cases), 3156 // user-defined conversion sequences that can convert from the source 3157 // type to the destination type or (when a conversion function is 3158 // used) to a derived class thereof are enumerated as described in 3159 // 13.3.1.4, and the best one is chosen through overload resolution 3160 // (13.3). 3161 else 3162 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this); 3163 return; 3164 } 3165 3166 if (NumArgs > 1) { 3167 SetFailed(FK_TooManyInitsForScalar); 3168 return; 3169 } 3170 assert(NumArgs == 1 && "Zero-argument case handled above"); 3171 3172 // - Otherwise, if the source type is a (possibly cv-qualified) class 3173 // type, conversion functions are considered. 3174 if (!SourceType.isNull() && SourceType->isRecordType()) { 3175 TryUserDefinedConversion(S, Entity, Kind, Initializer, *this); 3176 return; 3177 } 3178 3179 // - Otherwise, the initial value of the object being initialized is the 3180 // (possibly converted) value of the initializer expression. Standard 3181 // conversions (Clause 4) will be used, if necessary, to convert the 3182 // initializer expression to the cv-unqualified version of the 3183 // destination type; no user-defined conversions are considered. 3184 if (S.TryImplicitConversion(*this, Entity, Initializer, 3185 /*SuppressUserConversions*/ true, 3186 /*AllowExplicitConversions*/ false, 3187 /*InOverloadResolution*/ false)) 3188 { 3189 if (Initializer->getType() == Context.OverloadTy) 3190 SetFailed(InitializationSequence::FK_AddressOfOverloadFailed); 3191 else 3192 SetFailed(InitializationSequence::FK_ConversionFailed); 3193 } 3194 else 3195 setSequenceKind(StandardConversion); 3196} 3197 3198InitializationSequence::~InitializationSequence() { 3199 for (llvm::SmallVectorImpl<Step>::iterator Step = Steps.begin(), 3200 StepEnd = Steps.end(); 3201 Step != StepEnd; ++Step) 3202 Step->Destroy(); 3203} 3204 3205//===----------------------------------------------------------------------===// 3206// Perform initialization 3207//===----------------------------------------------------------------------===// 3208static Sema::AssignmentAction 3209getAssignmentAction(const InitializedEntity &Entity) { 3210 switch(Entity.getKind()) { 3211 case InitializedEntity::EK_Variable: 3212 case InitializedEntity::EK_New: 3213 case InitializedEntity::EK_Exception: 3214 case InitializedEntity::EK_Base: 3215 return Sema::AA_Initializing; 3216 3217 case InitializedEntity::EK_Parameter: 3218 if (Entity.getDecl() && 3219 isa<ObjCMethodDecl>(Entity.getDecl()->getDeclContext())) 3220 return Sema::AA_Sending; 3221 3222 return Sema::AA_Passing; 3223 3224 case InitializedEntity::EK_Result: 3225 return Sema::AA_Returning; 3226 3227 case InitializedEntity::EK_Temporary: 3228 // FIXME: Can we tell apart casting vs. converting? 3229 return Sema::AA_Casting; 3230 3231 case InitializedEntity::EK_Member: 3232 case InitializedEntity::EK_ArrayElement: 3233 case InitializedEntity::EK_VectorElement: 3234 case InitializedEntity::EK_BlockElement: 3235 return Sema::AA_Initializing; 3236 } 3237 3238 return Sema::AA_Converting; 3239} 3240 3241/// \brief Whether we should binding a created object as a temporary when 3242/// initializing the given entity. 3243static bool shouldBindAsTemporary(const InitializedEntity &Entity) { 3244 switch (Entity.getKind()) { 3245 case InitializedEntity::EK_ArrayElement: 3246 case InitializedEntity::EK_Member: 3247 case InitializedEntity::EK_Result: 3248 case InitializedEntity::EK_New: 3249 case InitializedEntity::EK_Variable: 3250 case InitializedEntity::EK_Base: 3251 case InitializedEntity::EK_VectorElement: 3252 case InitializedEntity::EK_Exception: 3253 case InitializedEntity::EK_BlockElement: 3254 return false; 3255 3256 case InitializedEntity::EK_Parameter: 3257 case InitializedEntity::EK_Temporary: 3258 return true; 3259 } 3260 3261 llvm_unreachable("missed an InitializedEntity kind?"); 3262} 3263 3264/// \brief Whether the given entity, when initialized with an object 3265/// created for that initialization, requires destruction. 3266static bool shouldDestroyTemporary(const InitializedEntity &Entity) { 3267 switch (Entity.getKind()) { 3268 case InitializedEntity::EK_Member: 3269 case InitializedEntity::EK_Result: 3270 case InitializedEntity::EK_New: 3271 case InitializedEntity::EK_Base: 3272 case InitializedEntity::EK_VectorElement: 3273 case InitializedEntity::EK_BlockElement: 3274 return false; 3275 3276 case InitializedEntity::EK_Variable: 3277 case InitializedEntity::EK_Parameter: 3278 case InitializedEntity::EK_Temporary: 3279 case InitializedEntity::EK_ArrayElement: 3280 case InitializedEntity::EK_Exception: 3281 return true; 3282 } 3283 3284 llvm_unreachable("missed an InitializedEntity kind?"); 3285} 3286 3287/// \brief Make a (potentially elidable) temporary copy of the object 3288/// provided by the given initializer by calling the appropriate copy 3289/// constructor. 3290/// 3291/// \param S The Sema object used for type-checking. 3292/// 3293/// \param T The type of the temporary object, which must either by 3294/// the type of the initializer expression or a superclass thereof. 3295/// 3296/// \param Enter The entity being initialized. 3297/// 3298/// \param CurInit The initializer expression. 3299/// 3300/// \param IsExtraneousCopy Whether this is an "extraneous" copy that 3301/// is permitted in C++03 (but not C++0x) when binding a reference to 3302/// an rvalue. 3303/// 3304/// \returns An expression that copies the initializer expression into 3305/// a temporary object, or an error expression if a copy could not be 3306/// created. 3307static ExprResult CopyObject(Sema &S, 3308 QualType T, 3309 const InitializedEntity &Entity, 3310 ExprResult CurInit, 3311 bool IsExtraneousCopy) { 3312 // Determine which class type we're copying to. 3313 Expr *CurInitExpr = (Expr *)CurInit.get(); 3314 CXXRecordDecl *Class = 0; 3315 if (const RecordType *Record = T->getAs<RecordType>()) 3316 Class = cast<CXXRecordDecl>(Record->getDecl()); 3317 if (!Class) 3318 return move(CurInit); 3319 3320 // C++0x [class.copy]p32: 3321 // When certain criteria are met, an implementation is allowed to 3322 // omit the copy/move construction of a class object, even if the 3323 // copy/move constructor and/or destructor for the object have 3324 // side effects. [...] 3325 // - when a temporary class object that has not been bound to a 3326 // reference (12.2) would be copied/moved to a class object 3327 // with the same cv-unqualified type, the copy/move operation 3328 // can be omitted by constructing the temporary object 3329 // directly into the target of the omitted copy/move 3330 // 3331 // Note that the other three bullets are handled elsewhere. Copy 3332 // elision for return statements and throw expressions are handled as part 3333 // of constructor initialization, while copy elision for exception handlers 3334 // is handled by the run-time. 3335 bool Elidable = CurInitExpr->isTemporaryObject(S.Context, Class); 3336 SourceLocation Loc; 3337 switch (Entity.getKind()) { 3338 case InitializedEntity::EK_Result: 3339 Loc = Entity.getReturnLoc(); 3340 break; 3341 3342 case InitializedEntity::EK_Exception: 3343 Loc = Entity.getThrowLoc(); 3344 break; 3345 3346 case InitializedEntity::EK_Variable: 3347 Loc = Entity.getDecl()->getLocation(); 3348 break; 3349 3350 case InitializedEntity::EK_ArrayElement: 3351 case InitializedEntity::EK_Member: 3352 case InitializedEntity::EK_Parameter: 3353 case InitializedEntity::EK_Temporary: 3354 case InitializedEntity::EK_New: 3355 case InitializedEntity::EK_Base: 3356 case InitializedEntity::EK_VectorElement: 3357 case InitializedEntity::EK_BlockElement: 3358 Loc = CurInitExpr->getLocStart(); 3359 break; 3360 } 3361 3362 // Make sure that the type we are copying is complete. 3363 if (S.RequireCompleteType(Loc, T, S.PDiag(diag::err_temp_copy_incomplete))) 3364 return move(CurInit); 3365 3366 // Perform overload resolution using the class's copy/move constructors. 3367 DeclContext::lookup_iterator Con, ConEnd; 3368 OverloadCandidateSet CandidateSet(Loc); 3369 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(Class); 3370 Con != ConEnd; ++Con) { 3371 // Only consider copy/move constructors and constructor templates. Per 3372 // C++0x [dcl.init]p16, second bullet to class types, this 3373 // initialization is direct-initialization. 3374 CXXConstructorDecl *Constructor = 0; 3375 3376 if ((Constructor = dyn_cast<CXXConstructorDecl>(*Con))) { 3377 // Handle copy/moveconstructors, only. 3378 if (!Constructor || Constructor->isInvalidDecl() || 3379 !Constructor->isCopyOrMoveConstructor() || 3380 !Constructor->isConvertingConstructor(/*AllowExplicit=*/true)) 3381 continue; 3382 3383 DeclAccessPair FoundDecl 3384 = DeclAccessPair::make(Constructor, Constructor->getAccess()); 3385 S.AddOverloadCandidate(Constructor, FoundDecl, 3386 &CurInitExpr, 1, CandidateSet); 3387 continue; 3388 } 3389 3390 // Handle constructor templates. 3391 FunctionTemplateDecl *ConstructorTmpl = cast<FunctionTemplateDecl>(*Con); 3392 if (ConstructorTmpl->isInvalidDecl()) 3393 continue; 3394 3395 Constructor = cast<CXXConstructorDecl>( 3396 ConstructorTmpl->getTemplatedDecl()); 3397 if (!Constructor->isConvertingConstructor(/*AllowExplicit=*/true)) 3398 continue; 3399 3400 // FIXME: Do we need to limit this to copy-constructor-like 3401 // candidates? 3402 DeclAccessPair FoundDecl 3403 = DeclAccessPair::make(ConstructorTmpl, ConstructorTmpl->getAccess()); 3404 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 0, 3405 &CurInitExpr, 1, CandidateSet, true); 3406 } 3407 3408 OverloadCandidateSet::iterator Best; 3409 switch (CandidateSet.BestViableFunction(S, Loc, Best)) { 3410 case OR_Success: 3411 break; 3412 3413 case OR_No_Viable_Function: 3414 S.Diag(Loc, IsExtraneousCopy && !S.isSFINAEContext() 3415 ? diag::ext_rvalue_to_reference_temp_copy_no_viable 3416 : diag::err_temp_copy_no_viable) 3417 << (int)Entity.getKind() << CurInitExpr->getType() 3418 << CurInitExpr->getSourceRange(); 3419 CandidateSet.NoteCandidates(S, OCD_AllCandidates, &CurInitExpr, 1); 3420 if (!IsExtraneousCopy || S.isSFINAEContext()) 3421 return ExprError(); 3422 return move(CurInit); 3423 3424 case OR_Ambiguous: 3425 S.Diag(Loc, diag::err_temp_copy_ambiguous) 3426 << (int)Entity.getKind() << CurInitExpr->getType() 3427 << CurInitExpr->getSourceRange(); 3428 CandidateSet.NoteCandidates(S, OCD_ViableCandidates, &CurInitExpr, 1); 3429 return ExprError(); 3430 3431 case OR_Deleted: 3432 S.Diag(Loc, diag::err_temp_copy_deleted) 3433 << (int)Entity.getKind() << CurInitExpr->getType() 3434 << CurInitExpr->getSourceRange(); 3435 S.Diag(Best->Function->getLocation(), diag::note_unavailable_here) 3436 << Best->Function->isDeleted(); 3437 return ExprError(); 3438 } 3439 3440 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function); 3441 ASTOwningVector<Expr*> ConstructorArgs(S); 3442 CurInit.release(); // Ownership transferred into MultiExprArg, below. 3443 3444 S.CheckConstructorAccess(Loc, Constructor, Entity, 3445 Best->FoundDecl.getAccess(), IsExtraneousCopy); 3446 3447 if (IsExtraneousCopy) { 3448 // If this is a totally extraneous copy for C++03 reference 3449 // binding purposes, just return the original initialization 3450 // expression. We don't generate an (elided) copy operation here 3451 // because doing so would require us to pass down a flag to avoid 3452 // infinite recursion, where each step adds another extraneous, 3453 // elidable copy. 3454 3455 // Instantiate the default arguments of any extra parameters in 3456 // the selected copy constructor, as if we were going to create a 3457 // proper call to the copy constructor. 3458 for (unsigned I = 1, N = Constructor->getNumParams(); I != N; ++I) { 3459 ParmVarDecl *Parm = Constructor->getParamDecl(I); 3460 if (S.RequireCompleteType(Loc, Parm->getType(), 3461 S.PDiag(diag::err_call_incomplete_argument))) 3462 break; 3463 3464 // Build the default argument expression; we don't actually care 3465 // if this succeeds or not, because this routine will complain 3466 // if there was a problem. 3467 S.BuildCXXDefaultArgExpr(Loc, Constructor, Parm); 3468 } 3469 3470 return S.Owned(CurInitExpr); 3471 } 3472 3473 // Determine the arguments required to actually perform the 3474 // constructor call (we might have derived-to-base conversions, or 3475 // the copy constructor may have default arguments). 3476 if (S.CompleteConstructorCall(Constructor, MultiExprArg(&CurInitExpr, 1), 3477 Loc, ConstructorArgs)) 3478 return ExprError(); 3479 3480 // Actually perform the constructor call. 3481 CurInit = S.BuildCXXConstructExpr(Loc, T, Constructor, Elidable, 3482 move_arg(ConstructorArgs), 3483 /*ZeroInit*/ false, 3484 CXXConstructExpr::CK_Complete, 3485 SourceRange()); 3486 3487 // If we're supposed to bind temporaries, do so. 3488 if (!CurInit.isInvalid() && shouldBindAsTemporary(Entity)) 3489 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 3490 return move(CurInit); 3491} 3492 3493void InitializationSequence::PrintInitLocationNote(Sema &S, 3494 const InitializedEntity &Entity) { 3495 if (Entity.getKind() == InitializedEntity::EK_Parameter && Entity.getDecl()) { 3496 if (Entity.getDecl()->getLocation().isInvalid()) 3497 return; 3498 3499 if (Entity.getDecl()->getDeclName()) 3500 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_named_here) 3501 << Entity.getDecl()->getDeclName(); 3502 else 3503 S.Diag(Entity.getDecl()->getLocation(), diag::note_parameter_here); 3504 } 3505} 3506 3507ExprResult 3508InitializationSequence::Perform(Sema &S, 3509 const InitializedEntity &Entity, 3510 const InitializationKind &Kind, 3511 MultiExprArg Args, 3512 QualType *ResultType) { 3513 if (SequenceKind == FailedSequence) { 3514 unsigned NumArgs = Args.size(); 3515 Diagnose(S, Entity, Kind, (Expr **)Args.release(), NumArgs); 3516 return ExprError(); 3517 } 3518 3519 if (SequenceKind == DependentSequence) { 3520 // If the declaration is a non-dependent, incomplete array type 3521 // that has an initializer, then its type will be completed once 3522 // the initializer is instantiated. 3523 if (ResultType && !Entity.getType()->isDependentType() && 3524 Args.size() == 1) { 3525 QualType DeclType = Entity.getType(); 3526 if (const IncompleteArrayType *ArrayT 3527 = S.Context.getAsIncompleteArrayType(DeclType)) { 3528 // FIXME: We don't currently have the ability to accurately 3529 // compute the length of an initializer list without 3530 // performing full type-checking of the initializer list 3531 // (since we have to determine where braces are implicitly 3532 // introduced and such). So, we fall back to making the array 3533 // type a dependently-sized array type with no specified 3534 // bound. 3535 if (isa<InitListExpr>((Expr *)Args.get()[0])) { 3536 SourceRange Brackets; 3537 3538 // Scavange the location of the brackets from the entity, if we can. 3539 if (DeclaratorDecl *DD = Entity.getDecl()) { 3540 if (TypeSourceInfo *TInfo = DD->getTypeSourceInfo()) { 3541 TypeLoc TL = TInfo->getTypeLoc(); 3542 if (IncompleteArrayTypeLoc *ArrayLoc 3543 = dyn_cast<IncompleteArrayTypeLoc>(&TL)) 3544 Brackets = ArrayLoc->getBracketsRange(); 3545 } 3546 } 3547 3548 *ResultType 3549 = S.Context.getDependentSizedArrayType(ArrayT->getElementType(), 3550 /*NumElts=*/0, 3551 ArrayT->getSizeModifier(), 3552 ArrayT->getIndexTypeCVRQualifiers(), 3553 Brackets); 3554 } 3555 3556 } 3557 } 3558 3559 if (Kind.getKind() == InitializationKind::IK_Copy || Kind.isExplicitCast()) 3560 return ExprResult(Args.release()[0]); 3561 3562 if (Args.size() == 0) 3563 return S.Owned((Expr *)0); 3564 3565 unsigned NumArgs = Args.size(); 3566 return S.Owned(new (S.Context) ParenListExpr(S.Context, 3567 SourceLocation(), 3568 (Expr **)Args.release(), 3569 NumArgs, 3570 SourceLocation())); 3571 } 3572 3573 if (SequenceKind == NoInitialization) 3574 return S.Owned((Expr *)0); 3575 3576 QualType DestType = Entity.getType().getNonReferenceType(); 3577 // FIXME: Ugly hack around the fact that Entity.getType() is not 3578 // the same as Entity.getDecl()->getType() in cases involving type merging, 3579 // and we want latter when it makes sense. 3580 if (ResultType) 3581 *ResultType = Entity.getDecl() ? Entity.getDecl()->getType() : 3582 Entity.getType(); 3583 3584 ExprResult CurInit = S.Owned((Expr *)0); 3585 3586 assert(!Steps.empty() && "Cannot have an empty initialization sequence"); 3587 3588 // For initialization steps that start with a single initializer, 3589 // grab the only argument out the Args and place it into the "current" 3590 // initializer. 3591 switch (Steps.front().Kind) { 3592 case SK_ResolveAddressOfOverloadedFunction: 3593 case SK_CastDerivedToBaseRValue: 3594 case SK_CastDerivedToBaseXValue: 3595 case SK_CastDerivedToBaseLValue: 3596 case SK_BindReference: 3597 case SK_BindReferenceToTemporary: 3598 case SK_ExtraneousCopyToTemporary: 3599 case SK_UserConversion: 3600 case SK_QualificationConversionLValue: 3601 case SK_QualificationConversionXValue: 3602 case SK_QualificationConversionRValue: 3603 case SK_ConversionSequence: 3604 case SK_ListInitialization: 3605 case SK_CAssignment: 3606 case SK_StringInit: 3607 case SK_ObjCObjectConversion: { 3608 assert(Args.size() == 1); 3609 Expr *CurInitExpr = Args.get()[0]; 3610 if (!CurInitExpr) return ExprError(); 3611 3612 // Read from a property when initializing something with it. 3613 if (CurInitExpr->getObjectKind() == OK_ObjCProperty) 3614 S.ConvertPropertyForRValue(CurInitExpr); 3615 3616 CurInit = ExprResult(CurInitExpr); 3617 break; 3618 } 3619 3620 case SK_ConstructorInitialization: 3621 case SK_ZeroInitialization: 3622 break; 3623 } 3624 3625 // Walk through the computed steps for the initialization sequence, 3626 // performing the specified conversions along the way. 3627 bool ConstructorInitRequiresZeroInit = false; 3628 for (step_iterator Step = step_begin(), StepEnd = step_end(); 3629 Step != StepEnd; ++Step) { 3630 if (CurInit.isInvalid()) 3631 return ExprError(); 3632 3633 Expr *CurInitExpr = CurInit.get(); 3634 QualType SourceType = CurInitExpr? CurInitExpr->getType() : QualType(); 3635 3636 switch (Step->Kind) { 3637 case SK_ResolveAddressOfOverloadedFunction: 3638 // Overload resolution determined which function invoke; update the 3639 // initializer to reflect that choice. 3640 S.CheckAddressOfMemberAccess(CurInitExpr, Step->Function.FoundDecl); 3641 S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation()); 3642 CurInit = S.FixOverloadedFunctionReference(move(CurInit), 3643 Step->Function.FoundDecl, 3644 Step->Function.Function); 3645 break; 3646 3647 case SK_CastDerivedToBaseRValue: 3648 case SK_CastDerivedToBaseXValue: 3649 case SK_CastDerivedToBaseLValue: { 3650 // We have a derived-to-base cast that produces either an rvalue or an 3651 // lvalue. Perform that cast. 3652 3653 CXXCastPath BasePath; 3654 3655 // Casts to inaccessible base classes are allowed with C-style casts. 3656 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast(); 3657 if (S.CheckDerivedToBaseConversion(SourceType, Step->Type, 3658 CurInitExpr->getLocStart(), 3659 CurInitExpr->getSourceRange(), 3660 &BasePath, IgnoreBaseAccess)) 3661 return ExprError(); 3662 3663 if (S.BasePathInvolvesVirtualBase(BasePath)) { 3664 QualType T = SourceType; 3665 if (const PointerType *Pointer = T->getAs<PointerType>()) 3666 T = Pointer->getPointeeType(); 3667 if (const RecordType *RecordTy = T->getAs<RecordType>()) 3668 S.MarkVTableUsed(CurInitExpr->getLocStart(), 3669 cast<CXXRecordDecl>(RecordTy->getDecl())); 3670 } 3671 3672 ExprValueKind VK = 3673 Step->Kind == SK_CastDerivedToBaseLValue ? 3674 VK_LValue : 3675 (Step->Kind == SK_CastDerivedToBaseXValue ? 3676 VK_XValue : 3677 VK_RValue); 3678 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, 3679 Step->Type, 3680 CK_DerivedToBase, 3681 CurInit.get(), 3682 &BasePath, VK)); 3683 break; 3684 } 3685 3686 case SK_BindReference: 3687 if (FieldDecl *BitField = CurInitExpr->getBitField()) { 3688 // References cannot bind to bit fields (C++ [dcl.init.ref]p5). 3689 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield) 3690 << Entity.getType().isVolatileQualified() 3691 << BitField->getDeclName() 3692 << CurInitExpr->getSourceRange(); 3693 S.Diag(BitField->getLocation(), diag::note_bitfield_decl); 3694 return ExprError(); 3695 } 3696 3697 if (CurInitExpr->refersToVectorElement()) { 3698 // References cannot bind to vector elements. 3699 S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element) 3700 << Entity.getType().isVolatileQualified() 3701 << CurInitExpr->getSourceRange(); 3702 PrintInitLocationNote(S, Entity); 3703 return ExprError(); 3704 } 3705 3706 // Reference binding does not have any corresponding ASTs. 3707 3708 // Check exception specifications 3709 if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType)) 3710 return ExprError(); 3711 3712 break; 3713 3714 case SK_BindReferenceToTemporary: 3715 // Reference binding does not have any corresponding ASTs. 3716 3717 // Check exception specifications 3718 if (S.CheckExceptionSpecCompatibility(CurInitExpr, DestType)) 3719 return ExprError(); 3720 3721 break; 3722 3723 case SK_ExtraneousCopyToTemporary: 3724 CurInit = CopyObject(S, Step->Type, Entity, move(CurInit), 3725 /*IsExtraneousCopy=*/true); 3726 break; 3727 3728 case SK_UserConversion: { 3729 // We have a user-defined conversion that invokes either a constructor 3730 // or a conversion function. 3731 CastKind CastKind; 3732 bool IsCopy = false; 3733 FunctionDecl *Fn = Step->Function.Function; 3734 DeclAccessPair FoundFn = Step->Function.FoundDecl; 3735 bool CreatedObject = false; 3736 bool IsLvalue = false; 3737 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) { 3738 // Build a call to the selected constructor. 3739 ASTOwningVector<Expr*> ConstructorArgs(S); 3740 SourceLocation Loc = CurInitExpr->getLocStart(); 3741 CurInit.release(); // Ownership transferred into MultiExprArg, below. 3742 3743 // Determine the arguments required to actually perform the constructor 3744 // call. 3745 if (S.CompleteConstructorCall(Constructor, 3746 MultiExprArg(&CurInitExpr, 1), 3747 Loc, ConstructorArgs)) 3748 return ExprError(); 3749 3750 // Build the an expression that constructs a temporary. 3751 CurInit = S.BuildCXXConstructExpr(Loc, Step->Type, Constructor, 3752 move_arg(ConstructorArgs), 3753 /*ZeroInit*/ false, 3754 CXXConstructExpr::CK_Complete, 3755 SourceRange()); 3756 if (CurInit.isInvalid()) 3757 return ExprError(); 3758 3759 S.CheckConstructorAccess(Kind.getLocation(), Constructor, Entity, 3760 FoundFn.getAccess()); 3761 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()); 3762 3763 CastKind = CK_ConstructorConversion; 3764 QualType Class = S.Context.getTypeDeclType(Constructor->getParent()); 3765 if (S.Context.hasSameUnqualifiedType(SourceType, Class) || 3766 S.IsDerivedFrom(SourceType, Class)) 3767 IsCopy = true; 3768 3769 CreatedObject = true; 3770 } else { 3771 // Build a call to the conversion function. 3772 CXXConversionDecl *Conversion = cast<CXXConversionDecl>(Fn); 3773 IsLvalue = Conversion->getResultType()->isLValueReferenceType(); 3774 S.CheckMemberOperatorAccess(Kind.getLocation(), CurInitExpr, 0, 3775 FoundFn); 3776 S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation()); 3777 3778 // FIXME: Should we move this initialization into a separate 3779 // derived-to-base conversion? I believe the answer is "no", because 3780 // we don't want to turn off access control here for c-style casts. 3781 if (S.PerformObjectArgumentInitialization(CurInitExpr, /*Qualifier=*/0, 3782 FoundFn, Conversion)) 3783 return ExprError(); 3784 3785 // Do a little dance to make sure that CurInit has the proper 3786 // pointer. 3787 CurInit.release(); 3788 3789 // Build the actual call to the conversion function. 3790 CurInit = S.BuildCXXMemberCallExpr(CurInitExpr, FoundFn, Conversion); 3791 if (CurInit.isInvalid() || !CurInit.get()) 3792 return ExprError(); 3793 3794 CastKind = CK_UserDefinedConversion; 3795 3796 CreatedObject = Conversion->getResultType()->isRecordType(); 3797 } 3798 3799 bool RequiresCopy = !IsCopy && 3800 getKind() != InitializationSequence::ReferenceBinding; 3801 if (RequiresCopy || shouldBindAsTemporary(Entity)) 3802 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 3803 else if (CreatedObject && shouldDestroyTemporary(Entity)) { 3804 CurInitExpr = static_cast<Expr *>(CurInit.get()); 3805 QualType T = CurInitExpr->getType(); 3806 if (const RecordType *Record = T->getAs<RecordType>()) { 3807 CXXDestructorDecl *Destructor 3808 = S.LookupDestructor(cast<CXXRecordDecl>(Record->getDecl())); 3809 S.CheckDestructorAccess(CurInitExpr->getLocStart(), Destructor, 3810 S.PDiag(diag::err_access_dtor_temp) << T); 3811 S.MarkDeclarationReferenced(CurInitExpr->getLocStart(), Destructor); 3812 S.DiagnoseUseOfDecl(Destructor, CurInitExpr->getLocStart()); 3813 } 3814 } 3815 3816 CurInitExpr = CurInit.takeAs<Expr>(); 3817 // FIXME: xvalues 3818 CurInit = S.Owned(ImplicitCastExpr::Create(S.Context, 3819 CurInitExpr->getType(), 3820 CastKind, CurInitExpr, 0, 3821 IsLvalue ? VK_LValue : VK_RValue)); 3822 3823 if (RequiresCopy) 3824 CurInit = CopyObject(S, Entity.getType().getNonReferenceType(), Entity, 3825 move(CurInit), /*IsExtraneousCopy=*/false); 3826 3827 break; 3828 } 3829 3830 case SK_QualificationConversionLValue: 3831 case SK_QualificationConversionXValue: 3832 case SK_QualificationConversionRValue: { 3833 // Perform a qualification conversion; these can never go wrong. 3834 ExprValueKind VK = 3835 Step->Kind == SK_QualificationConversionLValue ? 3836 VK_LValue : 3837 (Step->Kind == SK_QualificationConversionXValue ? 3838 VK_XValue : 3839 VK_RValue); 3840 S.ImpCastExprToType(CurInitExpr, Step->Type, CK_NoOp, VK); 3841 CurInit.release(); 3842 CurInit = S.Owned(CurInitExpr); 3843 break; 3844 } 3845 3846 case SK_ConversionSequence: { 3847 bool IgnoreBaseAccess = Kind.isCStyleOrFunctionalCast(); 3848 3849 if (S.PerformImplicitConversion(CurInitExpr, Step->Type, *Step->ICS, 3850 getAssignmentAction(Entity), 3851 IgnoreBaseAccess)) 3852 return ExprError(); 3853 3854 CurInit.release(); 3855 CurInit = S.Owned(CurInitExpr); 3856 break; 3857 } 3858 3859 case SK_ListInitialization: { 3860 InitListExpr *InitList = cast<InitListExpr>(CurInitExpr); 3861 QualType Ty = Step->Type; 3862 if (S.CheckInitList(Entity, InitList, ResultType? *ResultType : Ty)) 3863 return ExprError(); 3864 3865 CurInit.release(); 3866 CurInit = S.Owned(InitList); 3867 break; 3868 } 3869 3870 case SK_ConstructorInitialization: { 3871 unsigned NumArgs = Args.size(); 3872 CXXConstructorDecl *Constructor 3873 = cast<CXXConstructorDecl>(Step->Function.Function); 3874 3875 // Build a call to the selected constructor. 3876 ASTOwningVector<Expr*> ConstructorArgs(S); 3877 SourceLocation Loc = (Kind.isCopyInit() && Kind.getEqualLoc().isValid()) 3878 ? Kind.getEqualLoc() 3879 : Kind.getLocation(); 3880 3881 if (Kind.getKind() == InitializationKind::IK_Default) { 3882 // Force even a trivial, implicit default constructor to be 3883 // semantically checked. We do this explicitly because we don't build 3884 // the definition for completely trivial constructors. 3885 CXXRecordDecl *ClassDecl = Constructor->getParent(); 3886 assert(ClassDecl && "No parent class for constructor."); 3887 if (Constructor->isImplicit() && Constructor->isDefaultConstructor() && 3888 ClassDecl->hasTrivialConstructor() && !Constructor->isUsed(false)) 3889 S.DefineImplicitDefaultConstructor(Loc, Constructor); 3890 } 3891 3892 // Determine the arguments required to actually perform the constructor 3893 // call. 3894 if (S.CompleteConstructorCall(Constructor, move(Args), 3895 Loc, ConstructorArgs)) 3896 return ExprError(); 3897 3898 3899 if (Entity.getKind() == InitializedEntity::EK_Temporary && 3900 NumArgs != 1 && // FIXME: Hack to work around cast weirdness 3901 (Kind.getKind() == InitializationKind::IK_Direct || 3902 Kind.getKind() == InitializationKind::IK_Value)) { 3903 // An explicitly-constructed temporary, e.g., X(1, 2). 3904 unsigned NumExprs = ConstructorArgs.size(); 3905 Expr **Exprs = (Expr **)ConstructorArgs.take(); 3906 S.MarkDeclarationReferenced(Loc, Constructor); 3907 S.DiagnoseUseOfDecl(Constructor, Loc); 3908 3909 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo(); 3910 if (!TSInfo) 3911 TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc); 3912 3913 CurInit = S.Owned(new (S.Context) CXXTemporaryObjectExpr(S.Context, 3914 Constructor, 3915 TSInfo, 3916 Exprs, 3917 NumExprs, 3918 Kind.getParenRange(), 3919 ConstructorInitRequiresZeroInit)); 3920 } else { 3921 CXXConstructExpr::ConstructionKind ConstructKind = 3922 CXXConstructExpr::CK_Complete; 3923 3924 if (Entity.getKind() == InitializedEntity::EK_Base) { 3925 ConstructKind = Entity.getBaseSpecifier()->isVirtual() ? 3926 CXXConstructExpr::CK_VirtualBase : 3927 CXXConstructExpr::CK_NonVirtualBase; 3928 } 3929 3930 // Only get the parenthesis range if it is a direct construction. 3931 SourceRange parenRange = 3932 Kind.getKind() == InitializationKind::IK_Direct ? 3933 Kind.getParenRange() : SourceRange(); 3934 3935 // If the entity allows NRVO, mark the construction as elidable 3936 // unconditionally. 3937 if (Entity.allowsNRVO()) 3938 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(), 3939 Constructor, /*Elidable=*/true, 3940 move_arg(ConstructorArgs), 3941 ConstructorInitRequiresZeroInit, 3942 ConstructKind, 3943 parenRange); 3944 else 3945 CurInit = S.BuildCXXConstructExpr(Loc, Entity.getType(), 3946 Constructor, 3947 move_arg(ConstructorArgs), 3948 ConstructorInitRequiresZeroInit, 3949 ConstructKind, 3950 parenRange); 3951 } 3952 if (CurInit.isInvalid()) 3953 return ExprError(); 3954 3955 // Only check access if all of that succeeded. 3956 S.CheckConstructorAccess(Loc, Constructor, Entity, 3957 Step->Function.FoundDecl.getAccess()); 3958 S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Loc); 3959 3960 if (shouldBindAsTemporary(Entity)) 3961 CurInit = S.MaybeBindToTemporary(CurInit.takeAs<Expr>()); 3962 3963 break; 3964 } 3965 3966 case SK_ZeroInitialization: { 3967 step_iterator NextStep = Step; 3968 ++NextStep; 3969 if (NextStep != StepEnd && 3970 NextStep->Kind == SK_ConstructorInitialization) { 3971 // The need for zero-initialization is recorded directly into 3972 // the call to the object's constructor within the next step. 3973 ConstructorInitRequiresZeroInit = true; 3974 } else if (Kind.getKind() == InitializationKind::IK_Value && 3975 S.getLangOptions().CPlusPlus && 3976 !Kind.isImplicitValueInit()) { 3977 TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo(); 3978 if (!TSInfo) 3979 TSInfo = S.Context.getTrivialTypeSourceInfo(Step->Type, 3980 Kind.getRange().getBegin()); 3981 3982 CurInit = S.Owned(new (S.Context) CXXScalarValueInitExpr( 3983 TSInfo->getType().getNonLValueExprType(S.Context), 3984 TSInfo, 3985 Kind.getRange().getEnd())); 3986 } else { 3987 CurInit = S.Owned(new (S.Context) ImplicitValueInitExpr(Step->Type)); 3988 } 3989 break; 3990 } 3991 3992 case SK_CAssignment: { 3993 QualType SourceType = CurInitExpr->getType(); 3994 Sema::AssignConvertType ConvTy = 3995 S.CheckSingleAssignmentConstraints(Step->Type, CurInitExpr); 3996 3997 // If this is a call, allow conversion to a transparent union. 3998 if (ConvTy != Sema::Compatible && 3999 Entity.getKind() == InitializedEntity::EK_Parameter && 4000 S.CheckTransparentUnionArgumentConstraints(Step->Type, CurInitExpr) 4001 == Sema::Compatible) 4002 ConvTy = Sema::Compatible; 4003 4004 bool Complained; 4005 if (S.DiagnoseAssignmentResult(ConvTy, Kind.getLocation(), 4006 Step->Type, SourceType, 4007 CurInitExpr, 4008 getAssignmentAction(Entity), 4009 &Complained)) { 4010 PrintInitLocationNote(S, Entity); 4011 return ExprError(); 4012 } else if (Complained) 4013 PrintInitLocationNote(S, Entity); 4014 4015 CurInit.release(); 4016 CurInit = S.Owned(CurInitExpr); 4017 break; 4018 } 4019 4020 case SK_StringInit: { 4021 QualType Ty = Step->Type; 4022 CheckStringInit(CurInitExpr, ResultType ? *ResultType : Ty, S); 4023 break; 4024 } 4025 4026 case SK_ObjCObjectConversion: 4027 S.ImpCastExprToType(CurInitExpr, Step->Type, 4028 CK_ObjCObjectLValueCast, 4029 S.CastCategory(CurInitExpr)); 4030 CurInit.release(); 4031 CurInit = S.Owned(CurInitExpr); 4032 break; 4033 } 4034 } 4035 4036 // Diagnose non-fatal problems with the completed initialization. 4037 if (Entity.getKind() == InitializedEntity::EK_Member && 4038 cast<FieldDecl>(Entity.getDecl())->isBitField()) 4039 S.CheckBitFieldInitialization(Kind.getLocation(), 4040 cast<FieldDecl>(Entity.getDecl()), 4041 CurInit.get()); 4042 4043 return move(CurInit); 4044} 4045 4046//===----------------------------------------------------------------------===// 4047// Diagnose initialization failures 4048//===----------------------------------------------------------------------===// 4049bool InitializationSequence::Diagnose(Sema &S, 4050 const InitializedEntity &Entity, 4051 const InitializationKind &Kind, 4052 Expr **Args, unsigned NumArgs) { 4053 if (SequenceKind != FailedSequence) 4054 return false; 4055 4056 QualType DestType = Entity.getType(); 4057 switch (Failure) { 4058 case FK_TooManyInitsForReference: 4059 // FIXME: Customize for the initialized entity? 4060 if (NumArgs == 0) 4061 S.Diag(Kind.getLocation(), diag::err_reference_without_init) 4062 << DestType.getNonReferenceType(); 4063 else // FIXME: diagnostic below could be better! 4064 S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits) 4065 << SourceRange(Args[0]->getLocStart(), Args[NumArgs - 1]->getLocEnd()); 4066 break; 4067 4068 case FK_ArrayNeedsInitList: 4069 case FK_ArrayNeedsInitListOrStringLiteral: 4070 S.Diag(Kind.getLocation(), diag::err_array_init_not_init_list) 4071 << (Failure == FK_ArrayNeedsInitListOrStringLiteral); 4072 break; 4073 4074 case FK_AddressOfOverloadFailed: { 4075 DeclAccessPair Found; 4076 S.ResolveAddressOfOverloadedFunction(Args[0], 4077 DestType.getNonReferenceType(), 4078 true, 4079 Found); 4080 break; 4081 } 4082 4083 case FK_ReferenceInitOverloadFailed: 4084 case FK_UserConversionOverloadFailed: 4085 switch (FailedOverloadResult) { 4086 case OR_Ambiguous: 4087 if (Failure == FK_UserConversionOverloadFailed) 4088 S.Diag(Kind.getLocation(), diag::err_typecheck_ambiguous_condition) 4089 << Args[0]->getType() << DestType 4090 << Args[0]->getSourceRange(); 4091 else 4092 S.Diag(Kind.getLocation(), diag::err_ref_init_ambiguous) 4093 << DestType << Args[0]->getType() 4094 << Args[0]->getSourceRange(); 4095 4096 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, Args, NumArgs); 4097 break; 4098 4099 case OR_No_Viable_Function: 4100 S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition) 4101 << Args[0]->getType() << DestType.getNonReferenceType() 4102 << Args[0]->getSourceRange(); 4103 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args, NumArgs); 4104 break; 4105 4106 case OR_Deleted: { 4107 S.Diag(Kind.getLocation(), diag::err_typecheck_deleted_function) 4108 << Args[0]->getType() << DestType.getNonReferenceType() 4109 << Args[0]->getSourceRange(); 4110 OverloadCandidateSet::iterator Best; 4111 OverloadingResult Ovl 4112 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best, 4113 true); 4114 if (Ovl == OR_Deleted) { 4115 S.Diag(Best->Function->getLocation(), diag::note_unavailable_here) 4116 << Best->Function->isDeleted(); 4117 } else { 4118 llvm_unreachable("Inconsistent overload resolution?"); 4119 } 4120 break; 4121 } 4122 4123 case OR_Success: 4124 llvm_unreachable("Conversion did not fail!"); 4125 break; 4126 } 4127 break; 4128 4129 case FK_NonConstLValueReferenceBindingToTemporary: 4130 case FK_NonConstLValueReferenceBindingToUnrelated: 4131 S.Diag(Kind.getLocation(), 4132 Failure == FK_NonConstLValueReferenceBindingToTemporary 4133 ? diag::err_lvalue_reference_bind_to_temporary 4134 : diag::err_lvalue_reference_bind_to_unrelated) 4135 << DestType.getNonReferenceType().isVolatileQualified() 4136 << DestType.getNonReferenceType() 4137 << Args[0]->getType() 4138 << Args[0]->getSourceRange(); 4139 break; 4140 4141 case FK_RValueReferenceBindingToLValue: 4142 S.Diag(Kind.getLocation(), diag::err_lvalue_to_rvalue_ref) 4143 << DestType.getNonReferenceType() << Args[0]->getType() 4144 << Args[0]->getSourceRange(); 4145 break; 4146 4147 case FK_ReferenceInitDropsQualifiers: 4148 S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals) 4149 << DestType.getNonReferenceType() 4150 << Args[0]->getType() 4151 << Args[0]->getSourceRange(); 4152 break; 4153 4154 case FK_ReferenceInitFailed: 4155 S.Diag(Kind.getLocation(), diag::err_reference_bind_failed) 4156 << DestType.getNonReferenceType() 4157 << Args[0]->isLValue() 4158 << Args[0]->getType() 4159 << Args[0]->getSourceRange(); 4160 break; 4161 4162 case FK_ConversionFailed: 4163 S.Diag(Kind.getLocation(), diag::err_init_conversion_failed) 4164 << (int)Entity.getKind() 4165 << DestType 4166 << Args[0]->isLValue() 4167 << Args[0]->getType() 4168 << Args[0]->getSourceRange(); 4169 break; 4170 4171 case FK_TooManyInitsForScalar: { 4172 SourceRange R; 4173 4174 if (InitListExpr *InitList = dyn_cast<InitListExpr>(Args[0])) 4175 R = SourceRange(InitList->getInit(0)->getLocEnd(), 4176 InitList->getLocEnd()); 4177 else 4178 R = SourceRange(Args[0]->getLocEnd(), Args[NumArgs - 1]->getLocEnd()); 4179 4180 R.setBegin(S.PP.getLocForEndOfToken(R.getBegin())); 4181 if (Kind.isCStyleOrFunctionalCast()) 4182 S.Diag(Kind.getLocation(), diag::err_builtin_func_cast_more_than_one_arg) 4183 << R; 4184 else 4185 S.Diag(Kind.getLocation(), diag::err_excess_initializers) 4186 << /*scalar=*/2 << R; 4187 break; 4188 } 4189 4190 case FK_ReferenceBindingToInitList: 4191 S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list) 4192 << DestType.getNonReferenceType() << Args[0]->getSourceRange(); 4193 break; 4194 4195 case FK_InitListBadDestinationType: 4196 S.Diag(Kind.getLocation(), diag::err_init_list_bad_dest_type) 4197 << (DestType->isRecordType()) << DestType << Args[0]->getSourceRange(); 4198 break; 4199 4200 case FK_ConstructorOverloadFailed: { 4201 SourceRange ArgsRange; 4202 if (NumArgs) 4203 ArgsRange = SourceRange(Args[0]->getLocStart(), 4204 Args[NumArgs - 1]->getLocEnd()); 4205 4206 // FIXME: Using "DestType" for the entity we're printing is probably 4207 // bad. 4208 switch (FailedOverloadResult) { 4209 case OR_Ambiguous: 4210 S.Diag(Kind.getLocation(), diag::err_ovl_ambiguous_init) 4211 << DestType << ArgsRange; 4212 FailedCandidateSet.NoteCandidates(S, OCD_ViableCandidates, 4213 Args, NumArgs); 4214 break; 4215 4216 case OR_No_Viable_Function: 4217 if (Kind.getKind() == InitializationKind::IK_Default && 4218 (Entity.getKind() == InitializedEntity::EK_Base || 4219 Entity.getKind() == InitializedEntity::EK_Member) && 4220 isa<CXXConstructorDecl>(S.CurContext)) { 4221 // This is implicit default initialization of a member or 4222 // base within a constructor. If no viable function was 4223 // found, notify the user that she needs to explicitly 4224 // initialize this base/member. 4225 CXXConstructorDecl *Constructor 4226 = cast<CXXConstructorDecl>(S.CurContext); 4227 if (Entity.getKind() == InitializedEntity::EK_Base) { 4228 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor) 4229 << Constructor->isImplicit() 4230 << S.Context.getTypeDeclType(Constructor->getParent()) 4231 << /*base=*/0 4232 << Entity.getType(); 4233 4234 RecordDecl *BaseDecl 4235 = Entity.getBaseSpecifier()->getType()->getAs<RecordType>() 4236 ->getDecl(); 4237 S.Diag(BaseDecl->getLocation(), diag::note_previous_decl) 4238 << S.Context.getTagDeclType(BaseDecl); 4239 } else { 4240 S.Diag(Kind.getLocation(), diag::err_missing_default_ctor) 4241 << Constructor->isImplicit() 4242 << S.Context.getTypeDeclType(Constructor->getParent()) 4243 << /*member=*/1 4244 << Entity.getName(); 4245 S.Diag(Entity.getDecl()->getLocation(), diag::note_field_decl); 4246 4247 if (const RecordType *Record 4248 = Entity.getType()->getAs<RecordType>()) 4249 S.Diag(Record->getDecl()->getLocation(), 4250 diag::note_previous_decl) 4251 << S.Context.getTagDeclType(Record->getDecl()); 4252 } 4253 break; 4254 } 4255 4256 S.Diag(Kind.getLocation(), diag::err_ovl_no_viable_function_in_init) 4257 << DestType << ArgsRange; 4258 FailedCandidateSet.NoteCandidates(S, OCD_AllCandidates, Args, NumArgs); 4259 break; 4260 4261 case OR_Deleted: { 4262 S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init) 4263 << true << DestType << ArgsRange; 4264 OverloadCandidateSet::iterator Best; 4265 OverloadingResult Ovl 4266 = FailedCandidateSet.BestViableFunction(S, Kind.getLocation(), Best); 4267 if (Ovl == OR_Deleted) { 4268 S.Diag(Best->Function->getLocation(), diag::note_unavailable_here) 4269 << Best->Function->isDeleted(); 4270 } else { 4271 llvm_unreachable("Inconsistent overload resolution?"); 4272 } 4273 break; 4274 } 4275 4276 case OR_Success: 4277 llvm_unreachable("Conversion did not fail!"); 4278 break; 4279 } 4280 break; 4281 } 4282 4283 case FK_DefaultInitOfConst: 4284 if (Entity.getKind() == InitializedEntity::EK_Member && 4285 isa<CXXConstructorDecl>(S.CurContext)) { 4286 // This is implicit default-initialization of a const member in 4287 // a constructor. Complain that it needs to be explicitly 4288 // initialized. 4289 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(S.CurContext); 4290 S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor) 4291 << Constructor->isImplicit() 4292 << S.Context.getTypeDeclType(Constructor->getParent()) 4293 << /*const=*/1 4294 << Entity.getName(); 4295 S.Diag(Entity.getDecl()->getLocation(), diag::note_previous_decl) 4296 << Entity.getName(); 4297 } else { 4298 S.Diag(Kind.getLocation(), diag::err_default_init_const) 4299 << DestType << (bool)DestType->getAs<RecordType>(); 4300 } 4301 break; 4302 4303 case FK_Incomplete: 4304 S.RequireCompleteType(Kind.getLocation(), DestType, 4305 diag::err_init_incomplete_type); 4306 break; 4307 } 4308 4309 PrintInitLocationNote(S, Entity); 4310 return true; 4311} 4312 4313void InitializationSequence::dump(llvm::raw_ostream &OS) const { 4314 switch (SequenceKind) { 4315 case FailedSequence: { 4316 OS << "Failed sequence: "; 4317 switch (Failure) { 4318 case FK_TooManyInitsForReference: 4319 OS << "too many initializers for reference"; 4320 break; 4321 4322 case FK_ArrayNeedsInitList: 4323 OS << "array requires initializer list"; 4324 break; 4325 4326 case FK_ArrayNeedsInitListOrStringLiteral: 4327 OS << "array requires initializer list or string literal"; 4328 break; 4329 4330 case FK_AddressOfOverloadFailed: 4331 OS << "address of overloaded function failed"; 4332 break; 4333 4334 case FK_ReferenceInitOverloadFailed: 4335 OS << "overload resolution for reference initialization failed"; 4336 break; 4337 4338 case FK_NonConstLValueReferenceBindingToTemporary: 4339 OS << "non-const lvalue reference bound to temporary"; 4340 break; 4341 4342 case FK_NonConstLValueReferenceBindingToUnrelated: 4343 OS << "non-const lvalue reference bound to unrelated type"; 4344 break; 4345 4346 case FK_RValueReferenceBindingToLValue: 4347 OS << "rvalue reference bound to an lvalue"; 4348 break; 4349 4350 case FK_ReferenceInitDropsQualifiers: 4351 OS << "reference initialization drops qualifiers"; 4352 break; 4353 4354 case FK_ReferenceInitFailed: 4355 OS << "reference initialization failed"; 4356 break; 4357 4358 case FK_ConversionFailed: 4359 OS << "conversion failed"; 4360 break; 4361 4362 case FK_TooManyInitsForScalar: 4363 OS << "too many initializers for scalar"; 4364 break; 4365 4366 case FK_ReferenceBindingToInitList: 4367 OS << "referencing binding to initializer list"; 4368 break; 4369 4370 case FK_InitListBadDestinationType: 4371 OS << "initializer list for non-aggregate, non-scalar type"; 4372 break; 4373 4374 case FK_UserConversionOverloadFailed: 4375 OS << "overloading failed for user-defined conversion"; 4376 break; 4377 4378 case FK_ConstructorOverloadFailed: 4379 OS << "constructor overloading failed"; 4380 break; 4381 4382 case FK_DefaultInitOfConst: 4383 OS << "default initialization of a const variable"; 4384 break; 4385 4386 case FK_Incomplete: 4387 OS << "initialization of incomplete type"; 4388 break; 4389 } 4390 OS << '\n'; 4391 return; 4392 } 4393 4394 case DependentSequence: 4395 OS << "Dependent sequence: "; 4396 return; 4397 4398 case UserDefinedConversion: 4399 OS << "User-defined conversion sequence: "; 4400 break; 4401 4402 case ConstructorInitialization: 4403 OS << "Constructor initialization sequence: "; 4404 break; 4405 4406 case ReferenceBinding: 4407 OS << "Reference binding: "; 4408 break; 4409 4410 case ListInitialization: 4411 OS << "List initialization: "; 4412 break; 4413 4414 case ZeroInitialization: 4415 OS << "Zero initialization\n"; 4416 return; 4417 4418 case NoInitialization: 4419 OS << "No initialization\n"; 4420 return; 4421 4422 case StandardConversion: 4423 OS << "Standard conversion: "; 4424 break; 4425 4426 case CAssignment: 4427 OS << "C assignment: "; 4428 break; 4429 4430 case StringInit: 4431 OS << "String initialization: "; 4432 break; 4433 } 4434 4435 for (step_iterator S = step_begin(), SEnd = step_end(); S != SEnd; ++S) { 4436 if (S != step_begin()) { 4437 OS << " -> "; 4438 } 4439 4440 switch (S->Kind) { 4441 case SK_ResolveAddressOfOverloadedFunction: 4442 OS << "resolve address of overloaded function"; 4443 break; 4444 4445 case SK_CastDerivedToBaseRValue: 4446 OS << "derived-to-base case (rvalue" << S->Type.getAsString() << ")"; 4447 break; 4448 4449 case SK_CastDerivedToBaseXValue: 4450 OS << "derived-to-base case (xvalue" << S->Type.getAsString() << ")"; 4451 break; 4452 4453 case SK_CastDerivedToBaseLValue: 4454 OS << "derived-to-base case (lvalue" << S->Type.getAsString() << ")"; 4455 break; 4456 4457 case SK_BindReference: 4458 OS << "bind reference to lvalue"; 4459 break; 4460 4461 case SK_BindReferenceToTemporary: 4462 OS << "bind reference to a temporary"; 4463 break; 4464 4465 case SK_ExtraneousCopyToTemporary: 4466 OS << "extraneous C++03 copy to temporary"; 4467 break; 4468 4469 case SK_UserConversion: 4470 OS << "user-defined conversion via " << S->Function.Function; 4471 break; 4472 4473 case SK_QualificationConversionRValue: 4474 OS << "qualification conversion (rvalue)"; 4475 4476 case SK_QualificationConversionXValue: 4477 OS << "qualification conversion (xvalue)"; 4478 4479 case SK_QualificationConversionLValue: 4480 OS << "qualification conversion (lvalue)"; 4481 break; 4482 4483 case SK_ConversionSequence: 4484 OS << "implicit conversion sequence ("; 4485 S->ICS->DebugPrint(); // FIXME: use OS 4486 OS << ")"; 4487 break; 4488 4489 case SK_ListInitialization: 4490 OS << "list initialization"; 4491 break; 4492 4493 case SK_ConstructorInitialization: 4494 OS << "constructor initialization"; 4495 break; 4496 4497 case SK_ZeroInitialization: 4498 OS << "zero initialization"; 4499 break; 4500 4501 case SK_CAssignment: 4502 OS << "C assignment"; 4503 break; 4504 4505 case SK_StringInit: 4506 OS << "string initialization"; 4507 break; 4508 4509 case SK_ObjCObjectConversion: 4510 OS << "Objective-C object conversion"; 4511 break; 4512 } 4513 } 4514} 4515 4516void InitializationSequence::dump() const { 4517 dump(llvm::errs()); 4518} 4519 4520//===----------------------------------------------------------------------===// 4521// Initialization helper functions 4522//===----------------------------------------------------------------------===// 4523ExprResult 4524Sema::PerformCopyInitialization(const InitializedEntity &Entity, 4525 SourceLocation EqualLoc, 4526 ExprResult Init) { 4527 if (Init.isInvalid()) 4528 return ExprError(); 4529 4530 Expr *InitE = Init.get(); 4531 assert(InitE && "No initialization expression?"); 4532 4533 if (EqualLoc.isInvalid()) 4534 EqualLoc = InitE->getLocStart(); 4535 4536 InitializationKind Kind = InitializationKind::CreateCopy(InitE->getLocStart(), 4537 EqualLoc); 4538 InitializationSequence Seq(*this, Entity, Kind, &InitE, 1); 4539 Init.release(); 4540 return Seq.Perform(*this, Entity, Kind, MultiExprArg(&InitE, 1)); 4541} 4542