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