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