SemaInit.cpp revision 34acd3e62c4ca3a2904f2515ff2a1a94c7d27b01
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 "Sema.h" 19#include "clang/Parse/Designator.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/ExprCXX.h" 22#include "clang/AST/ExprObjC.h" 23#include <map> 24using namespace clang; 25 26//===----------------------------------------------------------------------===// 27// Sema Initialization Checking 28//===----------------------------------------------------------------------===// 29 30static Expr *IsStringInit(Expr *Init, QualType DeclType, ASTContext &Context) { 31 const ArrayType *AT = Context.getAsArrayType(DeclType); 32 if (!AT) return 0; 33 34 if (!isa<ConstantArrayType>(AT) && !isa<IncompleteArrayType>(AT)) 35 return 0; 36 37 // See if this is a string literal or @encode. 38 Init = Init->IgnoreParens(); 39 40 // Handle @encode, which is a narrow string. 41 if (isa<ObjCEncodeExpr>(Init) && AT->getElementType()->isCharType()) 42 return Init; 43 44 // Otherwise we can only handle string literals. 45 StringLiteral *SL = dyn_cast<StringLiteral>(Init); 46 if (SL == 0) return 0; 47 48 QualType ElemTy = Context.getCanonicalType(AT->getElementType()); 49 // char array can be initialized with a narrow string. 50 // Only allow char x[] = "foo"; not char x[] = L"foo"; 51 if (!SL->isWide()) 52 return ElemTy->isCharType() ? Init : 0; 53 54 // wchar_t array can be initialized with a wide string: C99 6.7.8p15 (with 55 // correction from DR343): "An array with element type compatible with a 56 // qualified or unqualified version of wchar_t may be initialized by a wide 57 // string literal, optionally enclosed in braces." 58 if (Context.typesAreCompatible(Context.getWCharType(), 59 ElemTy.getUnqualifiedType())) 60 return Init; 61 62 return 0; 63} 64 65static bool CheckSingleInitializer(Expr *&Init, QualType DeclType, 66 bool DirectInit, Sema &S) { 67 // Get the type before calling CheckSingleAssignmentConstraints(), since 68 // it can promote the expression. 69 QualType InitType = Init->getType(); 70 71 if (S.getLangOptions().CPlusPlus) { 72 // FIXME: I dislike this error message. A lot. 73 if (S.PerformImplicitConversion(Init, DeclType, 74 "initializing", DirectInit)) { 75 ImplicitConversionSequence ICS; 76 OverloadCandidateSet CandidateSet; 77 if (S.IsUserDefinedConversion(Init, DeclType, ICS.UserDefined, 78 CandidateSet, 79 true, false, false) != S.OR_Ambiguous) 80 return S.Diag(Init->getSourceRange().getBegin(), 81 diag::err_typecheck_convert_incompatible) 82 << DeclType << Init->getType() << "initializing" 83 << Init->getSourceRange(); 84 S.Diag(Init->getSourceRange().getBegin(), 85 diag::err_typecheck_convert_ambiguous) 86 << DeclType << Init->getType() << Init->getSourceRange(); 87 S.PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/false); 88 return true; 89 } 90 return false; 91 } 92 93 Sema::AssignConvertType ConvTy = 94 S.CheckSingleAssignmentConstraints(DeclType, Init); 95 return S.DiagnoseAssignmentResult(ConvTy, Init->getLocStart(), DeclType, 96 InitType, Init, "initializing"); 97} 98 99static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) { 100 // Get the length of the string as parsed. 101 uint64_t StrLength = 102 cast<ConstantArrayType>(Str->getType())->getSize().getZExtValue(); 103 104 105 const ArrayType *AT = S.Context.getAsArrayType(DeclT); 106 if (const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(AT)) { 107 // C99 6.7.8p14. We have an array of character type with unknown size 108 // being initialized to a string literal. 109 llvm::APSInt ConstVal(32); 110 ConstVal = StrLength; 111 // Return a new array type (C99 6.7.8p22). 112 DeclT = S.Context.getConstantArrayWithoutExprType(IAT->getElementType(), 113 ConstVal, 114 ArrayType::Normal, 0); 115 return; 116 } 117 118 const ConstantArrayType *CAT = cast<ConstantArrayType>(AT); 119 120 // C99 6.7.8p14. We have an array of character type with known size. However, 121 // the size may be smaller or larger than the string we are initializing. 122 // FIXME: Avoid truncation for 64-bit length strings. 123 if (StrLength-1 > CAT->getSize().getZExtValue()) 124 S.Diag(Str->getSourceRange().getBegin(), 125 diag::warn_initializer_string_for_char_array_too_long) 126 << Str->getSourceRange(); 127 128 // Set the type to the actual size that we are initializing. If we have 129 // something like: 130 // char x[1] = "foo"; 131 // then this will set the string literal's type to char[1]. 132 Str->setType(DeclT); 133} 134 135bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType, 136 SourceLocation InitLoc, 137 DeclarationName InitEntity, bool DirectInit) { 138 if (DeclType->isDependentType() || 139 Init->isTypeDependent() || Init->isValueDependent()) 140 return false; 141 142 // C++ [dcl.init.ref]p1: 143 // A variable declared to be a T& or T&&, that is "reference to type T" 144 // (8.3.2), shall be initialized by an object, or function, of 145 // type T or by an object that can be converted into a T. 146 if (DeclType->isReferenceType()) 147 return CheckReferenceInit(Init, DeclType, 148 /*SuppressUserConversions=*/false, 149 /*AllowExplicit=*/DirectInit, 150 /*ForceRValue=*/false); 151 152 // C99 6.7.8p3: The type of the entity to be initialized shall be an array 153 // of unknown size ("[]") or an object type that is not a variable array type. 154 if (const VariableArrayType *VAT = Context.getAsVariableArrayType(DeclType)) 155 return Diag(InitLoc, diag::err_variable_object_no_init) 156 << VAT->getSizeExpr()->getSourceRange(); 157 158 InitListExpr *InitList = dyn_cast<InitListExpr>(Init); 159 if (!InitList) { 160 // FIXME: Handle wide strings 161 if (Expr *Str = IsStringInit(Init, DeclType, Context)) { 162 CheckStringInit(Str, DeclType, *this); 163 return false; 164 } 165 166 // C++ [dcl.init]p14: 167 // -- If the destination type is a (possibly cv-qualified) class 168 // type: 169 if (getLangOptions().CPlusPlus && DeclType->isRecordType()) { 170 QualType DeclTypeC = Context.getCanonicalType(DeclType); 171 QualType InitTypeC = Context.getCanonicalType(Init->getType()); 172 173 // -- If the initialization is direct-initialization, or if it is 174 // copy-initialization where the cv-unqualified version of the 175 // source type is the same class as, or a derived class of, the 176 // class of the destination, constructors are considered. 177 if ((DeclTypeC.getUnqualifiedType() == InitTypeC.getUnqualifiedType()) || 178 IsDerivedFrom(InitTypeC, DeclTypeC)) { 179 const CXXRecordDecl *RD = 180 cast<CXXRecordDecl>(DeclType->getAs<RecordType>()->getDecl()); 181 182 // No need to make a CXXConstructExpr if both the ctor and dtor are 183 // trivial. 184 if (RD->hasTrivialConstructor() && RD->hasTrivialDestructor()) 185 return false; 186 187 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 188 189 CXXConstructorDecl *Constructor 190 = PerformInitializationByConstructor(DeclType, 191 MultiExprArg(*this, 192 (void **)&Init, 1), 193 InitLoc, Init->getSourceRange(), 194 InitEntity, 195 DirectInit? IK_Direct : IK_Copy, 196 ConstructorArgs); 197 if (!Constructor) 198 return true; 199 200 OwningExprResult InitResult = 201 BuildCXXConstructExpr(/*FIXME:ConstructLoc*/SourceLocation(), 202 DeclType, Constructor, 203 move_arg(ConstructorArgs)); 204 if (InitResult.isInvalid()) 205 return true; 206 207 Init = InitResult.takeAs<Expr>(); 208 return false; 209 } 210 211 // -- Otherwise (i.e., for the remaining copy-initialization 212 // cases), user-defined conversion sequences that can 213 // convert from the source type to the destination type or 214 // (when a conversion function is used) to a derived class 215 // thereof are enumerated as described in 13.3.1.4, and the 216 // best one is chosen through overload resolution 217 // (13.3). If the conversion cannot be done or is 218 // ambiguous, the initialization is ill-formed. The 219 // function selected is called with the initializer 220 // expression as its argument; if the function is a 221 // constructor, the call initializes a temporary of the 222 // destination type. 223 // FIXME: We're pretending to do copy elision here; return to this when we 224 // have ASTs for such things. 225 if (!PerformImplicitConversion(Init, DeclType, "initializing")) 226 return false; 227 228 if (InitEntity) 229 return Diag(InitLoc, diag::err_cannot_initialize_decl) 230 << InitEntity << (int)(Init->isLvalue(Context) == Expr::LV_Valid) 231 << Init->getType() << Init->getSourceRange(); 232 return Diag(InitLoc, diag::err_cannot_initialize_decl_noname) 233 << DeclType << (int)(Init->isLvalue(Context) == Expr::LV_Valid) 234 << Init->getType() << Init->getSourceRange(); 235 } 236 237 // C99 6.7.8p16. 238 if (DeclType->isArrayType()) 239 return Diag(Init->getLocStart(), diag::err_array_init_list_required) 240 << Init->getSourceRange(); 241 242 return CheckSingleInitializer(Init, DeclType, DirectInit, *this); 243 } 244 245 bool hadError = CheckInitList(InitList, DeclType); 246 Init = InitList; 247 return hadError; 248} 249 250//===----------------------------------------------------------------------===// 251// Semantic checking for initializer lists. 252//===----------------------------------------------------------------------===// 253 254/// @brief Semantic checking for initializer lists. 255/// 256/// The InitListChecker class contains a set of routines that each 257/// handle the initialization of a certain kind of entity, e.g., 258/// arrays, vectors, struct/union types, scalars, etc. The 259/// InitListChecker itself performs a recursive walk of the subobject 260/// structure of the type to be initialized, while stepping through 261/// the initializer list one element at a time. The IList and Index 262/// parameters to each of the Check* routines contain the active 263/// (syntactic) initializer list and the index into that initializer 264/// list that represents the current initializer. Each routine is 265/// responsible for moving that Index forward as it consumes elements. 266/// 267/// Each Check* routine also has a StructuredList/StructuredIndex 268/// arguments, which contains the current the "structured" (semantic) 269/// initializer list and the index into that initializer list where we 270/// are copying initializers as we map them over to the semantic 271/// list. Once we have completed our recursive walk of the subobject 272/// structure, we will have constructed a full semantic initializer 273/// list. 274/// 275/// C99 designators cause changes in the initializer list traversal, 276/// because they make the initialization "jump" into a specific 277/// subobject and then continue the initialization from that 278/// point. CheckDesignatedInitializer() recursively steps into the 279/// designated subobject and manages backing out the recursion to 280/// initialize the subobjects after the one designated. 281namespace { 282class InitListChecker { 283 Sema &SemaRef; 284 bool hadError; 285 std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic; 286 InitListExpr *FullyStructuredList; 287 288 void CheckImplicitInitList(InitListExpr *ParentIList, QualType T, 289 unsigned &Index, InitListExpr *StructuredList, 290 unsigned &StructuredIndex, 291 bool TopLevelObject = false); 292 void CheckExplicitInitList(InitListExpr *IList, QualType &T, 293 unsigned &Index, InitListExpr *StructuredList, 294 unsigned &StructuredIndex, 295 bool TopLevelObject = false); 296 void CheckListElementTypes(InitListExpr *IList, QualType &DeclType, 297 bool SubobjectIsDesignatorContext, 298 unsigned &Index, 299 InitListExpr *StructuredList, 300 unsigned &StructuredIndex, 301 bool TopLevelObject = false); 302 void CheckSubElementType(InitListExpr *IList, QualType ElemType, 303 unsigned &Index, 304 InitListExpr *StructuredList, 305 unsigned &StructuredIndex); 306 void CheckScalarType(InitListExpr *IList, QualType DeclType, 307 unsigned &Index, 308 InitListExpr *StructuredList, 309 unsigned &StructuredIndex); 310 void CheckReferenceType(InitListExpr *IList, QualType DeclType, 311 unsigned &Index, 312 InitListExpr *StructuredList, 313 unsigned &StructuredIndex); 314 void CheckVectorType(InitListExpr *IList, QualType DeclType, unsigned &Index, 315 InitListExpr *StructuredList, 316 unsigned &StructuredIndex); 317 void CheckStructUnionTypes(InitListExpr *IList, QualType DeclType, 318 RecordDecl::field_iterator Field, 319 bool SubobjectIsDesignatorContext, unsigned &Index, 320 InitListExpr *StructuredList, 321 unsigned &StructuredIndex, 322 bool TopLevelObject = false); 323 void CheckArrayType(InitListExpr *IList, QualType &DeclType, 324 llvm::APSInt elementIndex, 325 bool SubobjectIsDesignatorContext, unsigned &Index, 326 InitListExpr *StructuredList, 327 unsigned &StructuredIndex); 328 bool CheckDesignatedInitializer(InitListExpr *IList, DesignatedInitExpr *DIE, 329 unsigned DesigIdx, 330 QualType &CurrentObjectType, 331 RecordDecl::field_iterator *NextField, 332 llvm::APSInt *NextElementIndex, 333 unsigned &Index, 334 InitListExpr *StructuredList, 335 unsigned &StructuredIndex, 336 bool FinishSubobjectInit, 337 bool TopLevelObject); 338 InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 339 QualType CurrentObjectType, 340 InitListExpr *StructuredList, 341 unsigned StructuredIndex, 342 SourceRange InitRange); 343 void UpdateStructuredListElement(InitListExpr *StructuredList, 344 unsigned &StructuredIndex, 345 Expr *expr); 346 int numArrayElements(QualType DeclType); 347 int numStructUnionElements(QualType DeclType); 348 349 void FillInValueInitializations(InitListExpr *ILE); 350public: 351 InitListChecker(Sema &S, InitListExpr *IL, QualType &T); 352 bool HadError() { return hadError; } 353 354 // @brief Retrieves the fully-structured initializer list used for 355 // semantic analysis and code generation. 356 InitListExpr *getFullyStructuredList() const { return FullyStructuredList; } 357}; 358} // end anonymous namespace 359 360/// Recursively replaces NULL values within the given initializer list 361/// with expressions that perform value-initialization of the 362/// appropriate type. 363void InitListChecker::FillInValueInitializations(InitListExpr *ILE) { 364 assert((ILE->getType() != SemaRef.Context.VoidTy) && 365 "Should not have void type"); 366 SourceLocation Loc = ILE->getSourceRange().getBegin(); 367 if (ILE->getSyntacticForm()) 368 Loc = ILE->getSyntacticForm()->getSourceRange().getBegin(); 369 370 if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) { 371 unsigned Init = 0, NumInits = ILE->getNumInits(); 372 for (RecordDecl::field_iterator 373 Field = RType->getDecl()->field_begin(), 374 FieldEnd = RType->getDecl()->field_end(); 375 Field != FieldEnd; ++Field) { 376 if (Field->isUnnamedBitfield()) 377 continue; 378 379 if (Init >= NumInits || !ILE->getInit(Init)) { 380 if (Field->getType()->isReferenceType()) { 381 // C++ [dcl.init.aggr]p9: 382 // If an incomplete or empty initializer-list leaves a 383 // member of reference type uninitialized, the program is 384 // ill-formed. 385 SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized) 386 << Field->getType() 387 << ILE->getSyntacticForm()->getSourceRange(); 388 SemaRef.Diag(Field->getLocation(), 389 diag::note_uninit_reference_member); 390 hadError = true; 391 return; 392 } else if (SemaRef.CheckValueInitialization(Field->getType(), Loc)) { 393 hadError = true; 394 return; 395 } 396 397 // FIXME: If value-initialization involves calling a constructor, should 398 // we make that call explicit in the representation (even when it means 399 // extending the initializer list)? 400 if (Init < NumInits && !hadError) 401 ILE->setInit(Init, 402 new (SemaRef.Context) ImplicitValueInitExpr(Field->getType())); 403 } else if (InitListExpr *InnerILE 404 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 405 FillInValueInitializations(InnerILE); 406 ++Init; 407 408 // Only look at the first initialization of a union. 409 if (RType->getDecl()->isUnion()) 410 break; 411 } 412 413 return; 414 } 415 416 QualType ElementType; 417 418 unsigned NumInits = ILE->getNumInits(); 419 unsigned NumElements = NumInits; 420 if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) { 421 ElementType = AType->getElementType(); 422 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) 423 NumElements = CAType->getSize().getZExtValue(); 424 } else if (const VectorType *VType = ILE->getType()->getAsVectorType()) { 425 ElementType = VType->getElementType(); 426 NumElements = VType->getNumElements(); 427 } else 428 ElementType = ILE->getType(); 429 430 for (unsigned Init = 0; Init != NumElements; ++Init) { 431 if (Init >= NumInits || !ILE->getInit(Init)) { 432 if (SemaRef.CheckValueInitialization(ElementType, Loc)) { 433 hadError = true; 434 return; 435 } 436 437 // FIXME: If value-initialization involves calling a constructor, should 438 // we make that call explicit in the representation (even when it means 439 // extending the initializer list)? 440 if (Init < NumInits && !hadError) 441 ILE->setInit(Init, 442 new (SemaRef.Context) ImplicitValueInitExpr(ElementType)); 443 } else if (InitListExpr *InnerILE 444 = dyn_cast<InitListExpr>(ILE->getInit(Init))) 445 FillInValueInitializations(InnerILE); 446 } 447} 448 449 450InitListChecker::InitListChecker(Sema &S, InitListExpr *IL, QualType &T) 451 : SemaRef(S) { 452 hadError = false; 453 454 unsigned newIndex = 0; 455 unsigned newStructuredIndex = 0; 456 FullyStructuredList 457 = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange()); 458 CheckExplicitInitList(IL, T, newIndex, FullyStructuredList, newStructuredIndex, 459 /*TopLevelObject=*/true); 460 461 if (!hadError) 462 FillInValueInitializations(FullyStructuredList); 463} 464 465int InitListChecker::numArrayElements(QualType DeclType) { 466 // FIXME: use a proper constant 467 int maxElements = 0x7FFFFFFF; 468 if (const ConstantArrayType *CAT = 469 SemaRef.Context.getAsConstantArrayType(DeclType)) { 470 maxElements = static_cast<int>(CAT->getSize().getZExtValue()); 471 } 472 return maxElements; 473} 474 475int InitListChecker::numStructUnionElements(QualType DeclType) { 476 RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl(); 477 int InitializableMembers = 0; 478 for (RecordDecl::field_iterator 479 Field = structDecl->field_begin(), 480 FieldEnd = structDecl->field_end(); 481 Field != FieldEnd; ++Field) { 482 if ((*Field)->getIdentifier() || !(*Field)->isBitField()) 483 ++InitializableMembers; 484 } 485 if (structDecl->isUnion()) 486 return std::min(InitializableMembers, 1); 487 return InitializableMembers - structDecl->hasFlexibleArrayMember(); 488} 489 490void InitListChecker::CheckImplicitInitList(InitListExpr *ParentIList, 491 QualType T, unsigned &Index, 492 InitListExpr *StructuredList, 493 unsigned &StructuredIndex, 494 bool TopLevelObject) { 495 int maxElements = 0; 496 497 if (T->isArrayType()) 498 maxElements = numArrayElements(T); 499 else if (T->isStructureType() || T->isUnionType()) 500 maxElements = numStructUnionElements(T); 501 else if (T->isVectorType()) 502 maxElements = T->getAsVectorType()->getNumElements(); 503 else 504 assert(0 && "CheckImplicitInitList(): Illegal type"); 505 506 if (maxElements == 0) { 507 SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(), 508 diag::err_implicit_empty_initializer); 509 ++Index; 510 hadError = true; 511 return; 512 } 513 514 // Build a structured initializer list corresponding to this subobject. 515 InitListExpr *StructuredSubobjectInitList 516 = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList, 517 StructuredIndex, 518 SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(), 519 ParentIList->getSourceRange().getEnd())); 520 unsigned StructuredSubobjectInitIndex = 0; 521 522 // Check the element types and build the structural subobject. 523 unsigned StartIndex = Index; 524 CheckListElementTypes(ParentIList, T, false, Index, 525 StructuredSubobjectInitList, 526 StructuredSubobjectInitIndex, 527 TopLevelObject); 528 unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1); 529 StructuredSubobjectInitList->setType(T); 530 531 // Update the structured sub-object initializer so that it's ending 532 // range corresponds with the end of the last initializer it used. 533 if (EndIndex < ParentIList->getNumInits()) { 534 SourceLocation EndLoc 535 = ParentIList->getInit(EndIndex)->getSourceRange().getEnd(); 536 StructuredSubobjectInitList->setRBraceLoc(EndLoc); 537 } 538} 539 540void InitListChecker::CheckExplicitInitList(InitListExpr *IList, QualType &T, 541 unsigned &Index, 542 InitListExpr *StructuredList, 543 unsigned &StructuredIndex, 544 bool TopLevelObject) { 545 assert(IList->isExplicit() && "Illegal Implicit InitListExpr"); 546 SyntacticToSemantic[IList] = StructuredList; 547 StructuredList->setSyntacticForm(IList); 548 CheckListElementTypes(IList, T, true, Index, StructuredList, 549 StructuredIndex, TopLevelObject); 550 IList->setType(T); 551 StructuredList->setType(T); 552 if (hadError) 553 return; 554 555 if (Index < IList->getNumInits()) { 556 // We have leftover initializers 557 if (StructuredIndex == 1 && 558 IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) { 559 unsigned DK = diag::warn_excess_initializers_in_char_array_initializer; 560 if (SemaRef.getLangOptions().CPlusPlus) { 561 DK = diag::err_excess_initializers_in_char_array_initializer; 562 hadError = true; 563 } 564 // Special-case 565 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 566 << IList->getInit(Index)->getSourceRange(); 567 } else if (!T->isIncompleteType()) { 568 // Don't complain for incomplete types, since we'll get an error 569 // elsewhere 570 QualType CurrentObjectType = StructuredList->getType(); 571 int initKind = 572 CurrentObjectType->isArrayType()? 0 : 573 CurrentObjectType->isVectorType()? 1 : 574 CurrentObjectType->isScalarType()? 2 : 575 CurrentObjectType->isUnionType()? 3 : 576 4; 577 578 unsigned DK = diag::warn_excess_initializers; 579 if (SemaRef.getLangOptions().CPlusPlus) { 580 DK = diag::err_excess_initializers; 581 hadError = true; 582 } 583 if (SemaRef.getLangOptions().OpenCL && initKind == 1) { 584 DK = diag::err_excess_initializers; 585 hadError = true; 586 } 587 588 SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK) 589 << initKind << IList->getInit(Index)->getSourceRange(); 590 } 591 } 592 593 if (T->isScalarType() && !TopLevelObject) 594 SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init) 595 << IList->getSourceRange() 596 << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocStart())) 597 << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocEnd())); 598} 599 600void InitListChecker::CheckListElementTypes(InitListExpr *IList, 601 QualType &DeclType, 602 bool SubobjectIsDesignatorContext, 603 unsigned &Index, 604 InitListExpr *StructuredList, 605 unsigned &StructuredIndex, 606 bool TopLevelObject) { 607 if (DeclType->isScalarType()) { 608 CheckScalarType(IList, DeclType, Index, StructuredList, StructuredIndex); 609 } else if (DeclType->isVectorType()) { 610 CheckVectorType(IList, DeclType, Index, StructuredList, StructuredIndex); 611 } else if (DeclType->isAggregateType()) { 612 if (DeclType->isRecordType()) { 613 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 614 CheckStructUnionTypes(IList, DeclType, RD->field_begin(), 615 SubobjectIsDesignatorContext, Index, 616 StructuredList, StructuredIndex, 617 TopLevelObject); 618 } else if (DeclType->isArrayType()) { 619 llvm::APSInt Zero( 620 SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()), 621 false); 622 CheckArrayType(IList, DeclType, Zero, SubobjectIsDesignatorContext, Index, 623 StructuredList, StructuredIndex); 624 } else 625 assert(0 && "Aggregate that isn't a structure or array?!"); 626 } else if (DeclType->isVoidType() || DeclType->isFunctionType()) { 627 // This type is invalid, issue a diagnostic. 628 ++Index; 629 SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type) 630 << DeclType; 631 hadError = true; 632 } else if (DeclType->isRecordType()) { 633 // C++ [dcl.init]p14: 634 // [...] If the class is an aggregate (8.5.1), and the initializer 635 // is a brace-enclosed list, see 8.5.1. 636 // 637 // Note: 8.5.1 is handled below; here, we diagnose the case where 638 // we have an initializer list and a destination type that is not 639 // an aggregate. 640 // FIXME: In C++0x, this is yet another form of initialization. 641 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 642 << DeclType << IList->getSourceRange(); 643 hadError = true; 644 } else if (DeclType->isReferenceType()) { 645 CheckReferenceType(IList, DeclType, Index, StructuredList, StructuredIndex); 646 } else { 647 // In C, all types are either scalars or aggregates, but 648 // additional handling is needed here for C++ (and possibly others?). 649 assert(0 && "Unsupported initializer type"); 650 } 651} 652 653void InitListChecker::CheckSubElementType(InitListExpr *IList, 654 QualType ElemType, 655 unsigned &Index, 656 InitListExpr *StructuredList, 657 unsigned &StructuredIndex) { 658 Expr *expr = IList->getInit(Index); 659 if (InitListExpr *SubInitList = dyn_cast<InitListExpr>(expr)) { 660 unsigned newIndex = 0; 661 unsigned newStructuredIndex = 0; 662 InitListExpr *newStructuredList 663 = getStructuredSubobjectInit(IList, Index, ElemType, 664 StructuredList, StructuredIndex, 665 SubInitList->getSourceRange()); 666 CheckExplicitInitList(SubInitList, ElemType, newIndex, 667 newStructuredList, newStructuredIndex); 668 ++StructuredIndex; 669 ++Index; 670 } else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) { 671 CheckStringInit(Str, ElemType, SemaRef); 672 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 673 ++Index; 674 } else if (ElemType->isScalarType()) { 675 CheckScalarType(IList, ElemType, Index, StructuredList, StructuredIndex); 676 } else if (ElemType->isReferenceType()) { 677 CheckReferenceType(IList, ElemType, Index, StructuredList, StructuredIndex); 678 } else { 679 if (SemaRef.getLangOptions().CPlusPlus) { 680 // C++ [dcl.init.aggr]p12: 681 // All implicit type conversions (clause 4) are considered when 682 // initializing the aggregate member with an ini- tializer from 683 // an initializer-list. If the initializer can initialize a 684 // member, the member is initialized. [...] 685 ImplicitConversionSequence ICS 686 = SemaRef.TryCopyInitialization(expr, ElemType, 687 /*SuppressUserConversions=*/false, 688 /*ForceRValue=*/false, 689 /*InOverloadResolution=*/false); 690 691 if (ICS.ConversionKind != ImplicitConversionSequence::BadConversion) { 692 if (SemaRef.PerformImplicitConversion(expr, ElemType, ICS, 693 "initializing")) 694 hadError = true; 695 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 696 ++Index; 697 return; 698 } 699 700 // Fall through for subaggregate initialization 701 } else { 702 // C99 6.7.8p13: 703 // 704 // The initializer for a structure or union object that has 705 // automatic storage duration shall be either an initializer 706 // list as described below, or a single expression that has 707 // compatible structure or union type. In the latter case, the 708 // initial value of the object, including unnamed members, is 709 // that of the expression. 710 if ((ElemType->isRecordType() || ElemType->isVectorType()) && 711 SemaRef.Context.hasSameUnqualifiedType(expr->getType(), ElemType)) { 712 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 713 ++Index; 714 return; 715 } 716 717 // Fall through for subaggregate initialization 718 } 719 720 // C++ [dcl.init.aggr]p12: 721 // 722 // [...] Otherwise, if the member is itself a non-empty 723 // subaggregate, brace elision is assumed and the initializer is 724 // considered for the initialization of the first member of 725 // the subaggregate. 726 if (ElemType->isAggregateType() || ElemType->isVectorType()) { 727 CheckImplicitInitList(IList, ElemType, Index, StructuredList, 728 StructuredIndex); 729 ++StructuredIndex; 730 } else { 731 // We cannot initialize this element, so let 732 // PerformCopyInitialization produce the appropriate diagnostic. 733 SemaRef.PerformCopyInitialization(expr, ElemType, "initializing"); 734 hadError = true; 735 ++Index; 736 ++StructuredIndex; 737 } 738 } 739} 740 741void InitListChecker::CheckScalarType(InitListExpr *IList, QualType DeclType, 742 unsigned &Index, 743 InitListExpr *StructuredList, 744 unsigned &StructuredIndex) { 745 if (Index < IList->getNumInits()) { 746 Expr *expr = IList->getInit(Index); 747 if (isa<InitListExpr>(expr)) { 748 SemaRef.Diag(IList->getLocStart(), 749 diag::err_many_braces_around_scalar_init) 750 << IList->getSourceRange(); 751 hadError = true; 752 ++Index; 753 ++StructuredIndex; 754 return; 755 } else if (isa<DesignatedInitExpr>(expr)) { 756 SemaRef.Diag(expr->getSourceRange().getBegin(), 757 diag::err_designator_for_scalar_init) 758 << DeclType << expr->getSourceRange(); 759 hadError = true; 760 ++Index; 761 ++StructuredIndex; 762 return; 763 } 764 765 Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer. 766 if (CheckSingleInitializer(expr, DeclType, false, SemaRef)) 767 hadError = true; // types weren't compatible. 768 else if (savExpr != expr) { 769 // The type was promoted, update initializer list. 770 IList->setInit(Index, expr); 771 } 772 if (hadError) 773 ++StructuredIndex; 774 else 775 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 776 ++Index; 777 } else { 778 SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer) 779 << IList->getSourceRange(); 780 hadError = true; 781 ++Index; 782 ++StructuredIndex; 783 return; 784 } 785} 786 787void InitListChecker::CheckReferenceType(InitListExpr *IList, QualType DeclType, 788 unsigned &Index, 789 InitListExpr *StructuredList, 790 unsigned &StructuredIndex) { 791 if (Index < IList->getNumInits()) { 792 Expr *expr = IList->getInit(Index); 793 if (isa<InitListExpr>(expr)) { 794 SemaRef.Diag(IList->getLocStart(), diag::err_init_non_aggr_init_list) 795 << DeclType << IList->getSourceRange(); 796 hadError = true; 797 ++Index; 798 ++StructuredIndex; 799 return; 800 } 801 802 Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer. 803 if (SemaRef.CheckReferenceInit(expr, DeclType, 804 /*SuppressUserConversions=*/false, 805 /*AllowExplicit=*/false, 806 /*ForceRValue=*/false)) 807 hadError = true; 808 else if (savExpr != expr) { 809 // The type was promoted, update initializer list. 810 IList->setInit(Index, expr); 811 } 812 if (hadError) 813 ++StructuredIndex; 814 else 815 UpdateStructuredListElement(StructuredList, StructuredIndex, expr); 816 ++Index; 817 } else { 818 // FIXME: It would be wonderful if we could point at the actual member. In 819 // general, it would be useful to pass location information down the stack, 820 // so that we know the location (or decl) of the "current object" being 821 // initialized. 822 SemaRef.Diag(IList->getLocStart(), 823 diag::err_init_reference_member_uninitialized) 824 << DeclType 825 << IList->getSourceRange(); 826 hadError = true; 827 ++Index; 828 ++StructuredIndex; 829 return; 830 } 831} 832 833void InitListChecker::CheckVectorType(InitListExpr *IList, QualType DeclType, 834 unsigned &Index, 835 InitListExpr *StructuredList, 836 unsigned &StructuredIndex) { 837 if (Index < IList->getNumInits()) { 838 const VectorType *VT = DeclType->getAsVectorType(); 839 unsigned maxElements = VT->getNumElements(); 840 unsigned numEltsInit = 0; 841 QualType elementType = VT->getElementType(); 842 843 if (!SemaRef.getLangOptions().OpenCL) { 844 for (unsigned i = 0; i < maxElements; ++i, ++numEltsInit) { 845 // Don't attempt to go past the end of the init list 846 if (Index >= IList->getNumInits()) 847 break; 848 CheckSubElementType(IList, elementType, Index, 849 StructuredList, StructuredIndex); 850 } 851 } else { 852 // OpenCL initializers allows vectors to be constructed from vectors. 853 for (unsigned i = 0; i < maxElements; ++i) { 854 // Don't attempt to go past the end of the init list 855 if (Index >= IList->getNumInits()) 856 break; 857 QualType IType = IList->getInit(Index)->getType(); 858 if (!IType->isVectorType()) { 859 CheckSubElementType(IList, elementType, Index, 860 StructuredList, StructuredIndex); 861 ++numEltsInit; 862 } else { 863 const VectorType *IVT = IType->getAsVectorType(); 864 unsigned numIElts = IVT->getNumElements(); 865 QualType VecType = SemaRef.Context.getExtVectorType(elementType, 866 numIElts); 867 CheckSubElementType(IList, VecType, Index, 868 StructuredList, StructuredIndex); 869 numEltsInit += numIElts; 870 } 871 } 872 } 873 874 // OpenCL & AltiVec require all elements to be initialized. 875 if (numEltsInit != maxElements) 876 if (SemaRef.getLangOptions().OpenCL || SemaRef.getLangOptions().AltiVec) 877 SemaRef.Diag(IList->getSourceRange().getBegin(), 878 diag::err_vector_incorrect_num_initializers) 879 << (numEltsInit < maxElements) << maxElements << numEltsInit; 880 } 881} 882 883void InitListChecker::CheckArrayType(InitListExpr *IList, QualType &DeclType, 884 llvm::APSInt elementIndex, 885 bool SubobjectIsDesignatorContext, 886 unsigned &Index, 887 InitListExpr *StructuredList, 888 unsigned &StructuredIndex) { 889 // Check for the special-case of initializing an array with a string. 890 if (Index < IList->getNumInits()) { 891 if (Expr *Str = IsStringInit(IList->getInit(Index), DeclType, 892 SemaRef.Context)) { 893 CheckStringInit(Str, DeclType, SemaRef); 894 // We place the string literal directly into the resulting 895 // initializer list. This is the only place where the structure 896 // of the structured initializer list doesn't match exactly, 897 // because doing so would involve allocating one character 898 // constant for each string. 899 UpdateStructuredListElement(StructuredList, StructuredIndex, Str); 900 StructuredList->resizeInits(SemaRef.Context, StructuredIndex); 901 ++Index; 902 return; 903 } 904 } 905 if (const VariableArrayType *VAT = 906 SemaRef.Context.getAsVariableArrayType(DeclType)) { 907 // Check for VLAs; in standard C it would be possible to check this 908 // earlier, but I don't know where clang accepts VLAs (gcc accepts 909 // them in all sorts of strange places). 910 SemaRef.Diag(VAT->getSizeExpr()->getLocStart(), 911 diag::err_variable_object_no_init) 912 << VAT->getSizeExpr()->getSourceRange(); 913 hadError = true; 914 ++Index; 915 ++StructuredIndex; 916 return; 917 } 918 919 // We might know the maximum number of elements in advance. 920 llvm::APSInt maxElements(elementIndex.getBitWidth(), 921 elementIndex.isUnsigned()); 922 bool maxElementsKnown = false; 923 if (const ConstantArrayType *CAT = 924 SemaRef.Context.getAsConstantArrayType(DeclType)) { 925 maxElements = CAT->getSize(); 926 elementIndex.extOrTrunc(maxElements.getBitWidth()); 927 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 928 maxElementsKnown = true; 929 } 930 931 QualType elementType = SemaRef.Context.getAsArrayType(DeclType) 932 ->getElementType(); 933 while (Index < IList->getNumInits()) { 934 Expr *Init = IList->getInit(Index); 935 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 936 // If we're not the subobject that matches up with the '{' for 937 // the designator, we shouldn't be handling the 938 // designator. Return immediately. 939 if (!SubobjectIsDesignatorContext) 940 return; 941 942 // Handle this designated initializer. elementIndex will be 943 // updated to be the next array element we'll initialize. 944 if (CheckDesignatedInitializer(IList, DIE, 0, 945 DeclType, 0, &elementIndex, Index, 946 StructuredList, StructuredIndex, true, 947 false)) { 948 hadError = true; 949 continue; 950 } 951 952 if (elementIndex.getBitWidth() > maxElements.getBitWidth()) 953 maxElements.extend(elementIndex.getBitWidth()); 954 else if (elementIndex.getBitWidth() < maxElements.getBitWidth()) 955 elementIndex.extend(maxElements.getBitWidth()); 956 elementIndex.setIsUnsigned(maxElements.isUnsigned()); 957 958 // If the array is of incomplete type, keep track of the number of 959 // elements in the initializer. 960 if (!maxElementsKnown && elementIndex > maxElements) 961 maxElements = elementIndex; 962 963 continue; 964 } 965 966 // If we know the maximum number of elements, and we've already 967 // hit it, stop consuming elements in the initializer list. 968 if (maxElementsKnown && elementIndex == maxElements) 969 break; 970 971 // Check this element. 972 CheckSubElementType(IList, elementType, Index, 973 StructuredList, StructuredIndex); 974 ++elementIndex; 975 976 // If the array is of incomplete type, keep track of the number of 977 // elements in the initializer. 978 if (!maxElementsKnown && elementIndex > maxElements) 979 maxElements = elementIndex; 980 } 981 if (!hadError && DeclType->isIncompleteArrayType()) { 982 // If this is an incomplete array type, the actual type needs to 983 // be calculated here. 984 llvm::APSInt Zero(maxElements.getBitWidth(), maxElements.isUnsigned()); 985 if (maxElements == Zero) { 986 // Sizing an array implicitly to zero is not allowed by ISO C, 987 // but is supported by GNU. 988 SemaRef.Diag(IList->getLocStart(), 989 diag::ext_typecheck_zero_array_size); 990 } 991 992 DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements, 993 ArrayType::Normal, 0); 994 } 995} 996 997void InitListChecker::CheckStructUnionTypes(InitListExpr *IList, 998 QualType DeclType, 999 RecordDecl::field_iterator Field, 1000 bool SubobjectIsDesignatorContext, 1001 unsigned &Index, 1002 InitListExpr *StructuredList, 1003 unsigned &StructuredIndex, 1004 bool TopLevelObject) { 1005 RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl(); 1006 1007 // If the record is invalid, some of it's members are invalid. To avoid 1008 // confusion, we forgo checking the intializer for the entire record. 1009 if (structDecl->isInvalidDecl()) { 1010 hadError = true; 1011 return; 1012 } 1013 1014 if (DeclType->isUnionType() && IList->getNumInits() == 0) { 1015 // Value-initialize the first named member of the union. 1016 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1017 for (RecordDecl::field_iterator FieldEnd = RD->field_end(); 1018 Field != FieldEnd; ++Field) { 1019 if (Field->getDeclName()) { 1020 StructuredList->setInitializedFieldInUnion(*Field); 1021 break; 1022 } 1023 } 1024 return; 1025 } 1026 1027 // If structDecl is a forward declaration, this loop won't do 1028 // anything except look at designated initializers; That's okay, 1029 // because an error should get printed out elsewhere. It might be 1030 // worthwhile to skip over the rest of the initializer, though. 1031 RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl(); 1032 RecordDecl::field_iterator FieldEnd = RD->field_end(); 1033 bool InitializedSomething = false; 1034 while (Index < IList->getNumInits()) { 1035 Expr *Init = IList->getInit(Index); 1036 1037 if (DesignatedInitExpr *DIE = dyn_cast<DesignatedInitExpr>(Init)) { 1038 // If we're not the subobject that matches up with the '{' for 1039 // the designator, we shouldn't be handling the 1040 // designator. Return immediately. 1041 if (!SubobjectIsDesignatorContext) 1042 return; 1043 1044 // Handle this designated initializer. Field will be updated to 1045 // the next field that we'll be initializing. 1046 if (CheckDesignatedInitializer(IList, DIE, 0, 1047 DeclType, &Field, 0, Index, 1048 StructuredList, StructuredIndex, 1049 true, TopLevelObject)) 1050 hadError = true; 1051 1052 InitializedSomething = true; 1053 continue; 1054 } 1055 1056 if (Field == FieldEnd) { 1057 // We've run out of fields. We're done. 1058 break; 1059 } 1060 1061 // We've already initialized a member of a union. We're done. 1062 if (InitializedSomething && DeclType->isUnionType()) 1063 break; 1064 1065 // If we've hit the flexible array member at the end, we're done. 1066 if (Field->getType()->isIncompleteArrayType()) 1067 break; 1068 1069 if (Field->isUnnamedBitfield()) { 1070 // Don't initialize unnamed bitfields, e.g. "int : 20;" 1071 ++Field; 1072 continue; 1073 } 1074 1075 CheckSubElementType(IList, Field->getType(), Index, 1076 StructuredList, StructuredIndex); 1077 InitializedSomething = true; 1078 1079 if (DeclType->isUnionType()) { 1080 // Initialize the first field within the union. 1081 StructuredList->setInitializedFieldInUnion(*Field); 1082 } 1083 1084 ++Field; 1085 } 1086 1087 if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() || 1088 Index >= IList->getNumInits()) 1089 return; 1090 1091 // Handle GNU flexible array initializers. 1092 if (!TopLevelObject && 1093 (!isa<InitListExpr>(IList->getInit(Index)) || 1094 cast<InitListExpr>(IList->getInit(Index))->getNumInits() > 0)) { 1095 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1096 diag::err_flexible_array_init_nonempty) 1097 << IList->getInit(Index)->getSourceRange().getBegin(); 1098 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1099 << *Field; 1100 hadError = true; 1101 ++Index; 1102 return; 1103 } else { 1104 SemaRef.Diag(IList->getInit(Index)->getSourceRange().getBegin(), 1105 diag::ext_flexible_array_init) 1106 << IList->getInit(Index)->getSourceRange().getBegin(); 1107 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1108 << *Field; 1109 } 1110 1111 if (isa<InitListExpr>(IList->getInit(Index))) 1112 CheckSubElementType(IList, Field->getType(), Index, StructuredList, 1113 StructuredIndex); 1114 else 1115 CheckImplicitInitList(IList, Field->getType(), Index, StructuredList, 1116 StructuredIndex); 1117} 1118 1119/// \brief Expand a field designator that refers to a member of an 1120/// anonymous struct or union into a series of field designators that 1121/// refers to the field within the appropriate subobject. 1122/// 1123/// Field/FieldIndex will be updated to point to the (new) 1124/// currently-designated field. 1125static void ExpandAnonymousFieldDesignator(Sema &SemaRef, 1126 DesignatedInitExpr *DIE, 1127 unsigned DesigIdx, 1128 FieldDecl *Field, 1129 RecordDecl::field_iterator &FieldIter, 1130 unsigned &FieldIndex) { 1131 typedef DesignatedInitExpr::Designator Designator; 1132 1133 // Build the path from the current object to the member of the 1134 // anonymous struct/union (backwards). 1135 llvm::SmallVector<FieldDecl *, 4> Path; 1136 SemaRef.BuildAnonymousStructUnionMemberPath(Field, Path); 1137 1138 // Build the replacement designators. 1139 llvm::SmallVector<Designator, 4> Replacements; 1140 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator 1141 FI = Path.rbegin(), FIEnd = Path.rend(); 1142 FI != FIEnd; ++FI) { 1143 if (FI + 1 == FIEnd) 1144 Replacements.push_back(Designator((IdentifierInfo *)0, 1145 DIE->getDesignator(DesigIdx)->getDotLoc(), 1146 DIE->getDesignator(DesigIdx)->getFieldLoc())); 1147 else 1148 Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(), 1149 SourceLocation())); 1150 Replacements.back().setField(*FI); 1151 } 1152 1153 // Expand the current designator into the set of replacement 1154 // designators, so we have a full subobject path down to where the 1155 // member of the anonymous struct/union is actually stored. 1156 DIE->ExpandDesignator(DesigIdx, &Replacements[0], 1157 &Replacements[0] + Replacements.size()); 1158 1159 // Update FieldIter/FieldIndex; 1160 RecordDecl *Record = cast<RecordDecl>(Path.back()->getDeclContext()); 1161 FieldIter = Record->field_begin(); 1162 FieldIndex = 0; 1163 for (RecordDecl::field_iterator FEnd = Record->field_end(); 1164 FieldIter != FEnd; ++FieldIter) { 1165 if (FieldIter->isUnnamedBitfield()) 1166 continue; 1167 1168 if (*FieldIter == Path.back()) 1169 return; 1170 1171 ++FieldIndex; 1172 } 1173 1174 assert(false && "Unable to find anonymous struct/union field"); 1175} 1176 1177/// @brief Check the well-formedness of a C99 designated initializer. 1178/// 1179/// Determines whether the designated initializer @p DIE, which 1180/// resides at the given @p Index within the initializer list @p 1181/// IList, is well-formed for a current object of type @p DeclType 1182/// (C99 6.7.8). The actual subobject that this designator refers to 1183/// within the current subobject is returned in either 1184/// @p NextField or @p NextElementIndex (whichever is appropriate). 1185/// 1186/// @param IList The initializer list in which this designated 1187/// initializer occurs. 1188/// 1189/// @param DIE The designated initializer expression. 1190/// 1191/// @param DesigIdx The index of the current designator. 1192/// 1193/// @param DeclType The type of the "current object" (C99 6.7.8p17), 1194/// into which the designation in @p DIE should refer. 1195/// 1196/// @param NextField If non-NULL and the first designator in @p DIE is 1197/// a field, this will be set to the field declaration corresponding 1198/// to the field named by the designator. 1199/// 1200/// @param NextElementIndex If non-NULL and the first designator in @p 1201/// DIE is an array designator or GNU array-range designator, this 1202/// will be set to the last index initialized by this designator. 1203/// 1204/// @param Index Index into @p IList where the designated initializer 1205/// @p DIE occurs. 1206/// 1207/// @param StructuredList The initializer list expression that 1208/// describes all of the subobject initializers in the order they'll 1209/// actually be initialized. 1210/// 1211/// @returns true if there was an error, false otherwise. 1212bool 1213InitListChecker::CheckDesignatedInitializer(InitListExpr *IList, 1214 DesignatedInitExpr *DIE, 1215 unsigned DesigIdx, 1216 QualType &CurrentObjectType, 1217 RecordDecl::field_iterator *NextField, 1218 llvm::APSInt *NextElementIndex, 1219 unsigned &Index, 1220 InitListExpr *StructuredList, 1221 unsigned &StructuredIndex, 1222 bool FinishSubobjectInit, 1223 bool TopLevelObject) { 1224 if (DesigIdx == DIE->size()) { 1225 // Check the actual initialization for the designated object type. 1226 bool prevHadError = hadError; 1227 1228 // Temporarily remove the designator expression from the 1229 // initializer list that the child calls see, so that we don't try 1230 // to re-process the designator. 1231 unsigned OldIndex = Index; 1232 IList->setInit(OldIndex, DIE->getInit()); 1233 1234 CheckSubElementType(IList, CurrentObjectType, Index, 1235 StructuredList, StructuredIndex); 1236 1237 // Restore the designated initializer expression in the syntactic 1238 // form of the initializer list. 1239 if (IList->getInit(OldIndex) != DIE->getInit()) 1240 DIE->setInit(IList->getInit(OldIndex)); 1241 IList->setInit(OldIndex, DIE); 1242 1243 return hadError && !prevHadError; 1244 } 1245 1246 bool IsFirstDesignator = (DesigIdx == 0); 1247 assert((IsFirstDesignator || StructuredList) && 1248 "Need a non-designated initializer list to start from"); 1249 1250 DesignatedInitExpr::Designator *D = DIE->getDesignator(DesigIdx); 1251 // Determine the structural initializer list that corresponds to the 1252 // current subobject. 1253 StructuredList = IsFirstDesignator? SyntacticToSemantic[IList] 1254 : getStructuredSubobjectInit(IList, Index, CurrentObjectType, 1255 StructuredList, StructuredIndex, 1256 SourceRange(D->getStartLocation(), 1257 DIE->getSourceRange().getEnd())); 1258 assert(StructuredList && "Expected a structured initializer list"); 1259 1260 if (D->isFieldDesignator()) { 1261 // C99 6.7.8p7: 1262 // 1263 // If a designator has the form 1264 // 1265 // . identifier 1266 // 1267 // then the current object (defined below) shall have 1268 // structure or union type and the identifier shall be the 1269 // name of a member of that type. 1270 const RecordType *RT = CurrentObjectType->getAs<RecordType>(); 1271 if (!RT) { 1272 SourceLocation Loc = D->getDotLoc(); 1273 if (Loc.isInvalid()) 1274 Loc = D->getFieldLoc(); 1275 SemaRef.Diag(Loc, diag::err_field_designator_non_aggr) 1276 << SemaRef.getLangOptions().CPlusPlus << CurrentObjectType; 1277 ++Index; 1278 return true; 1279 } 1280 1281 // Note: we perform a linear search of the fields here, despite 1282 // the fact that we have a faster lookup method, because we always 1283 // need to compute the field's index. 1284 FieldDecl *KnownField = D->getField(); 1285 IdentifierInfo *FieldName = D->getFieldName(); 1286 unsigned FieldIndex = 0; 1287 RecordDecl::field_iterator 1288 Field = RT->getDecl()->field_begin(), 1289 FieldEnd = RT->getDecl()->field_end(); 1290 for (; Field != FieldEnd; ++Field) { 1291 if (Field->isUnnamedBitfield()) 1292 continue; 1293 1294 if (KnownField == *Field || Field->getIdentifier() == FieldName) 1295 break; 1296 1297 ++FieldIndex; 1298 } 1299 1300 if (Field == FieldEnd) { 1301 // There was no normal field in the struct with the designated 1302 // name. Perform another lookup for this name, which may find 1303 // something that we can't designate (e.g., a member function), 1304 // may find nothing, or may find a member of an anonymous 1305 // struct/union. 1306 DeclContext::lookup_result Lookup = RT->getDecl()->lookup(FieldName); 1307 if (Lookup.first == Lookup.second) { 1308 // Name lookup didn't find anything. 1309 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_unknown) 1310 << FieldName << CurrentObjectType; 1311 ++Index; 1312 return true; 1313 } else if (!KnownField && isa<FieldDecl>(*Lookup.first) && 1314 cast<RecordDecl>((*Lookup.first)->getDeclContext()) 1315 ->isAnonymousStructOrUnion()) { 1316 // Handle an field designator that refers to a member of an 1317 // anonymous struct or union. 1318 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, 1319 cast<FieldDecl>(*Lookup.first), 1320 Field, FieldIndex); 1321 D = DIE->getDesignator(DesigIdx); 1322 } else { 1323 // Name lookup found something, but it wasn't a field. 1324 SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield) 1325 << FieldName; 1326 SemaRef.Diag((*Lookup.first)->getLocation(), 1327 diag::note_field_designator_found); 1328 ++Index; 1329 return true; 1330 } 1331 } else if (!KnownField && 1332 cast<RecordDecl>((*Field)->getDeclContext()) 1333 ->isAnonymousStructOrUnion()) { 1334 ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, *Field, 1335 Field, FieldIndex); 1336 D = DIE->getDesignator(DesigIdx); 1337 } 1338 1339 // All of the fields of a union are located at the same place in 1340 // the initializer list. 1341 if (RT->getDecl()->isUnion()) { 1342 FieldIndex = 0; 1343 StructuredList->setInitializedFieldInUnion(*Field); 1344 } 1345 1346 // Update the designator with the field declaration. 1347 D->setField(*Field); 1348 1349 // Make sure that our non-designated initializer list has space 1350 // for a subobject corresponding to this field. 1351 if (FieldIndex >= StructuredList->getNumInits()) 1352 StructuredList->resizeInits(SemaRef.Context, FieldIndex + 1); 1353 1354 // This designator names a flexible array member. 1355 if (Field->getType()->isIncompleteArrayType()) { 1356 bool Invalid = false; 1357 if ((DesigIdx + 1) != DIE->size()) { 1358 // We can't designate an object within the flexible array 1359 // member (because GCC doesn't allow it). 1360 DesignatedInitExpr::Designator *NextD 1361 = DIE->getDesignator(DesigIdx + 1); 1362 SemaRef.Diag(NextD->getStartLocation(), 1363 diag::err_designator_into_flexible_array_member) 1364 << SourceRange(NextD->getStartLocation(), 1365 DIE->getSourceRange().getEnd()); 1366 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1367 << *Field; 1368 Invalid = true; 1369 } 1370 1371 if (!hadError && !isa<InitListExpr>(DIE->getInit())) { 1372 // The initializer is not an initializer list. 1373 SemaRef.Diag(DIE->getInit()->getSourceRange().getBegin(), 1374 diag::err_flexible_array_init_needs_braces) 1375 << DIE->getInit()->getSourceRange(); 1376 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1377 << *Field; 1378 Invalid = true; 1379 } 1380 1381 // Handle GNU flexible array initializers. 1382 if (!Invalid && !TopLevelObject && 1383 cast<InitListExpr>(DIE->getInit())->getNumInits() > 0) { 1384 SemaRef.Diag(DIE->getSourceRange().getBegin(), 1385 diag::err_flexible_array_init_nonempty) 1386 << DIE->getSourceRange().getBegin(); 1387 SemaRef.Diag(Field->getLocation(), diag::note_flexible_array_member) 1388 << *Field; 1389 Invalid = true; 1390 } 1391 1392 if (Invalid) { 1393 ++Index; 1394 return true; 1395 } 1396 1397 // Initialize the array. 1398 bool prevHadError = hadError; 1399 unsigned newStructuredIndex = FieldIndex; 1400 unsigned OldIndex = Index; 1401 IList->setInit(Index, DIE->getInit()); 1402 CheckSubElementType(IList, Field->getType(), Index, 1403 StructuredList, newStructuredIndex); 1404 IList->setInit(OldIndex, DIE); 1405 if (hadError && !prevHadError) { 1406 ++Field; 1407 ++FieldIndex; 1408 if (NextField) 1409 *NextField = Field; 1410 StructuredIndex = FieldIndex; 1411 return true; 1412 } 1413 } else { 1414 // Recurse to check later designated subobjects. 1415 QualType FieldType = (*Field)->getType(); 1416 unsigned newStructuredIndex = FieldIndex; 1417 if (CheckDesignatedInitializer(IList, DIE, DesigIdx + 1, FieldType, 0, 0, 1418 Index, StructuredList, newStructuredIndex, 1419 true, false)) 1420 return true; 1421 } 1422 1423 // Find the position of the next field to be initialized in this 1424 // subobject. 1425 ++Field; 1426 ++FieldIndex; 1427 1428 // If this the first designator, our caller will continue checking 1429 // the rest of this struct/class/union subobject. 1430 if (IsFirstDesignator) { 1431 if (NextField) 1432 *NextField = Field; 1433 StructuredIndex = FieldIndex; 1434 return false; 1435 } 1436 1437 if (!FinishSubobjectInit) 1438 return false; 1439 1440 // We've already initialized something in the union; we're done. 1441 if (RT->getDecl()->isUnion()) 1442 return hadError; 1443 1444 // Check the remaining fields within this class/struct/union subobject. 1445 bool prevHadError = hadError; 1446 CheckStructUnionTypes(IList, CurrentObjectType, Field, false, Index, 1447 StructuredList, FieldIndex); 1448 return hadError && !prevHadError; 1449 } 1450 1451 // C99 6.7.8p6: 1452 // 1453 // If a designator has the form 1454 // 1455 // [ constant-expression ] 1456 // 1457 // then the current object (defined below) shall have array 1458 // type and the expression shall be an integer constant 1459 // expression. If the array is of unknown size, any 1460 // nonnegative value is valid. 1461 // 1462 // Additionally, cope with the GNU extension that permits 1463 // designators of the form 1464 // 1465 // [ constant-expression ... constant-expression ] 1466 const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType); 1467 if (!AT) { 1468 SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array) 1469 << CurrentObjectType; 1470 ++Index; 1471 return true; 1472 } 1473 1474 Expr *IndexExpr = 0; 1475 llvm::APSInt DesignatedStartIndex, DesignatedEndIndex; 1476 if (D->isArrayDesignator()) { 1477 IndexExpr = DIE->getArrayIndex(*D); 1478 DesignatedStartIndex = IndexExpr->EvaluateAsInt(SemaRef.Context); 1479 DesignatedEndIndex = DesignatedStartIndex; 1480 } else { 1481 assert(D->isArrayRangeDesignator() && "Need array-range designator"); 1482 1483 1484 DesignatedStartIndex = 1485 DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context); 1486 DesignatedEndIndex = 1487 DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context); 1488 IndexExpr = DIE->getArrayRangeEnd(*D); 1489 1490 if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue()) 1491 FullyStructuredList->sawArrayRangeDesignator(); 1492 } 1493 1494 if (isa<ConstantArrayType>(AT)) { 1495 llvm::APSInt MaxElements(cast<ConstantArrayType>(AT)->getSize(), false); 1496 DesignatedStartIndex.extOrTrunc(MaxElements.getBitWidth()); 1497 DesignatedStartIndex.setIsUnsigned(MaxElements.isUnsigned()); 1498 DesignatedEndIndex.extOrTrunc(MaxElements.getBitWidth()); 1499 DesignatedEndIndex.setIsUnsigned(MaxElements.isUnsigned()); 1500 if (DesignatedEndIndex >= MaxElements) { 1501 SemaRef.Diag(IndexExpr->getSourceRange().getBegin(), 1502 diag::err_array_designator_too_large) 1503 << DesignatedEndIndex.toString(10) << MaxElements.toString(10) 1504 << IndexExpr->getSourceRange(); 1505 ++Index; 1506 return true; 1507 } 1508 } else { 1509 // Make sure the bit-widths and signedness match. 1510 if (DesignatedStartIndex.getBitWidth() > DesignatedEndIndex.getBitWidth()) 1511 DesignatedEndIndex.extend(DesignatedStartIndex.getBitWidth()); 1512 else if (DesignatedStartIndex.getBitWidth() < 1513 DesignatedEndIndex.getBitWidth()) 1514 DesignatedStartIndex.extend(DesignatedEndIndex.getBitWidth()); 1515 DesignatedStartIndex.setIsUnsigned(true); 1516 DesignatedEndIndex.setIsUnsigned(true); 1517 } 1518 1519 // Make sure that our non-designated initializer list has space 1520 // for a subobject corresponding to this array element. 1521 if (DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits()) 1522 StructuredList->resizeInits(SemaRef.Context, 1523 DesignatedEndIndex.getZExtValue() + 1); 1524 1525 // Repeatedly perform subobject initializations in the range 1526 // [DesignatedStartIndex, DesignatedEndIndex]. 1527 1528 // Move to the next designator 1529 unsigned ElementIndex = DesignatedStartIndex.getZExtValue(); 1530 unsigned OldIndex = Index; 1531 while (DesignatedStartIndex <= DesignatedEndIndex) { 1532 // Recurse to check later designated subobjects. 1533 QualType ElementType = AT->getElementType(); 1534 Index = OldIndex; 1535 if (CheckDesignatedInitializer(IList, DIE, DesigIdx + 1, ElementType, 0, 0, 1536 Index, StructuredList, ElementIndex, 1537 (DesignatedStartIndex == DesignatedEndIndex), 1538 false)) 1539 return true; 1540 1541 // Move to the next index in the array that we'll be initializing. 1542 ++DesignatedStartIndex; 1543 ElementIndex = DesignatedStartIndex.getZExtValue(); 1544 } 1545 1546 // If this the first designator, our caller will continue checking 1547 // the rest of this array subobject. 1548 if (IsFirstDesignator) { 1549 if (NextElementIndex) 1550 *NextElementIndex = DesignatedStartIndex; 1551 StructuredIndex = ElementIndex; 1552 return false; 1553 } 1554 1555 if (!FinishSubobjectInit) 1556 return false; 1557 1558 // Check the remaining elements within this array subobject. 1559 bool prevHadError = hadError; 1560 CheckArrayType(IList, CurrentObjectType, DesignatedStartIndex, false, Index, 1561 StructuredList, ElementIndex); 1562 return hadError && !prevHadError; 1563} 1564 1565// Get the structured initializer list for a subobject of type 1566// @p CurrentObjectType. 1567InitListExpr * 1568InitListChecker::getStructuredSubobjectInit(InitListExpr *IList, unsigned Index, 1569 QualType CurrentObjectType, 1570 InitListExpr *StructuredList, 1571 unsigned StructuredIndex, 1572 SourceRange InitRange) { 1573 Expr *ExistingInit = 0; 1574 if (!StructuredList) 1575 ExistingInit = SyntacticToSemantic[IList]; 1576 else if (StructuredIndex < StructuredList->getNumInits()) 1577 ExistingInit = StructuredList->getInit(StructuredIndex); 1578 1579 if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit)) 1580 return Result; 1581 1582 if (ExistingInit) { 1583 // We are creating an initializer list that initializes the 1584 // subobjects of the current object, but there was already an 1585 // initialization that completely initialized the current 1586 // subobject, e.g., by a compound literal: 1587 // 1588 // struct X { int a, b; }; 1589 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 }; 1590 // 1591 // Here, xs[0].a == 0 and xs[0].b == 3, since the second, 1592 // designated initializer re-initializes the whole 1593 // subobject [0], overwriting previous initializers. 1594 SemaRef.Diag(InitRange.getBegin(), 1595 diag::warn_subobject_initializer_overrides) 1596 << InitRange; 1597 SemaRef.Diag(ExistingInit->getSourceRange().getBegin(), 1598 diag::note_previous_initializer) 1599 << /*FIXME:has side effects=*/0 1600 << ExistingInit->getSourceRange(); 1601 } 1602 1603 InitListExpr *Result 1604 = new (SemaRef.Context) InitListExpr(InitRange.getBegin(), 0, 0, 1605 InitRange.getEnd()); 1606 1607 Result->setType(CurrentObjectType); 1608 1609 // Pre-allocate storage for the structured initializer list. 1610 unsigned NumElements = 0; 1611 unsigned NumInits = 0; 1612 if (!StructuredList) 1613 NumInits = IList->getNumInits(); 1614 else if (Index < IList->getNumInits()) { 1615 if (InitListExpr *SubList = dyn_cast<InitListExpr>(IList->getInit(Index))) 1616 NumInits = SubList->getNumInits(); 1617 } 1618 1619 if (const ArrayType *AType 1620 = SemaRef.Context.getAsArrayType(CurrentObjectType)) { 1621 if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType)) { 1622 NumElements = CAType->getSize().getZExtValue(); 1623 // Simple heuristic so that we don't allocate a very large 1624 // initializer with many empty entries at the end. 1625 if (NumInits && NumElements > NumInits) 1626 NumElements = 0; 1627 } 1628 } else if (const VectorType *VType = CurrentObjectType->getAsVectorType()) 1629 NumElements = VType->getNumElements(); 1630 else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) { 1631 RecordDecl *RDecl = RType->getDecl(); 1632 if (RDecl->isUnion()) 1633 NumElements = 1; 1634 else 1635 NumElements = std::distance(RDecl->field_begin(), 1636 RDecl->field_end()); 1637 } 1638 1639 if (NumElements < NumInits) 1640 NumElements = IList->getNumInits(); 1641 1642 Result->reserveInits(NumElements); 1643 1644 // Link this new initializer list into the structured initializer 1645 // lists. 1646 if (StructuredList) 1647 StructuredList->updateInit(StructuredIndex, Result); 1648 else { 1649 Result->setSyntacticForm(IList); 1650 SyntacticToSemantic[IList] = Result; 1651 } 1652 1653 return Result; 1654} 1655 1656/// Update the initializer at index @p StructuredIndex within the 1657/// structured initializer list to the value @p expr. 1658void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList, 1659 unsigned &StructuredIndex, 1660 Expr *expr) { 1661 // No structured initializer list to update 1662 if (!StructuredList) 1663 return; 1664 1665 if (Expr *PrevInit = StructuredList->updateInit(StructuredIndex, expr)) { 1666 // This initializer overwrites a previous initializer. Warn. 1667 SemaRef.Diag(expr->getSourceRange().getBegin(), 1668 diag::warn_initializer_overrides) 1669 << expr->getSourceRange(); 1670 SemaRef.Diag(PrevInit->getSourceRange().getBegin(), 1671 diag::note_previous_initializer) 1672 << /*FIXME:has side effects=*/0 1673 << PrevInit->getSourceRange(); 1674 } 1675 1676 ++StructuredIndex; 1677} 1678 1679/// Check that the given Index expression is a valid array designator 1680/// value. This is essentailly just a wrapper around 1681/// VerifyIntegerConstantExpression that also checks for negative values 1682/// and produces a reasonable diagnostic if there is a 1683/// failure. Returns true if there was an error, false otherwise. If 1684/// everything went okay, Value will receive the value of the constant 1685/// expression. 1686static bool 1687CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) { 1688 SourceLocation Loc = Index->getSourceRange().getBegin(); 1689 1690 // Make sure this is an integer constant expression. 1691 if (S.VerifyIntegerConstantExpression(Index, &Value)) 1692 return true; 1693 1694 if (Value.isSigned() && Value.isNegative()) 1695 return S.Diag(Loc, diag::err_array_designator_negative) 1696 << Value.toString(10) << Index->getSourceRange(); 1697 1698 Value.setIsUnsigned(true); 1699 return false; 1700} 1701 1702Sema::OwningExprResult Sema::ActOnDesignatedInitializer(Designation &Desig, 1703 SourceLocation Loc, 1704 bool GNUSyntax, 1705 OwningExprResult Init) { 1706 typedef DesignatedInitExpr::Designator ASTDesignator; 1707 1708 bool Invalid = false; 1709 llvm::SmallVector<ASTDesignator, 32> Designators; 1710 llvm::SmallVector<Expr *, 32> InitExpressions; 1711 1712 // Build designators and check array designator expressions. 1713 for (unsigned Idx = 0; Idx < Desig.getNumDesignators(); ++Idx) { 1714 const Designator &D = Desig.getDesignator(Idx); 1715 switch (D.getKind()) { 1716 case Designator::FieldDesignator: 1717 Designators.push_back(ASTDesignator(D.getField(), D.getDotLoc(), 1718 D.getFieldLoc())); 1719 break; 1720 1721 case Designator::ArrayDesignator: { 1722 Expr *Index = static_cast<Expr *>(D.getArrayIndex()); 1723 llvm::APSInt IndexValue; 1724 if (!Index->isTypeDependent() && 1725 !Index->isValueDependent() && 1726 CheckArrayDesignatorExpr(*this, Index, IndexValue)) 1727 Invalid = true; 1728 else { 1729 Designators.push_back(ASTDesignator(InitExpressions.size(), 1730 D.getLBracketLoc(), 1731 D.getRBracketLoc())); 1732 InitExpressions.push_back(Index); 1733 } 1734 break; 1735 } 1736 1737 case Designator::ArrayRangeDesignator: { 1738 Expr *StartIndex = static_cast<Expr *>(D.getArrayRangeStart()); 1739 Expr *EndIndex = static_cast<Expr *>(D.getArrayRangeEnd()); 1740 llvm::APSInt StartValue; 1741 llvm::APSInt EndValue; 1742 bool StartDependent = StartIndex->isTypeDependent() || 1743 StartIndex->isValueDependent(); 1744 bool EndDependent = EndIndex->isTypeDependent() || 1745 EndIndex->isValueDependent(); 1746 if ((!StartDependent && 1747 CheckArrayDesignatorExpr(*this, StartIndex, StartValue)) || 1748 (!EndDependent && 1749 CheckArrayDesignatorExpr(*this, EndIndex, EndValue))) 1750 Invalid = true; 1751 else { 1752 // Make sure we're comparing values with the same bit width. 1753 if (StartDependent || EndDependent) { 1754 // Nothing to compute. 1755 } else if (StartValue.getBitWidth() > EndValue.getBitWidth()) 1756 EndValue.extend(StartValue.getBitWidth()); 1757 else if (StartValue.getBitWidth() < EndValue.getBitWidth()) 1758 StartValue.extend(EndValue.getBitWidth()); 1759 1760 if (!StartDependent && !EndDependent && EndValue < StartValue) { 1761 Diag(D.getEllipsisLoc(), diag::err_array_designator_empty_range) 1762 << StartValue.toString(10) << EndValue.toString(10) 1763 << StartIndex->getSourceRange() << EndIndex->getSourceRange(); 1764 Invalid = true; 1765 } else { 1766 Designators.push_back(ASTDesignator(InitExpressions.size(), 1767 D.getLBracketLoc(), 1768 D.getEllipsisLoc(), 1769 D.getRBracketLoc())); 1770 InitExpressions.push_back(StartIndex); 1771 InitExpressions.push_back(EndIndex); 1772 } 1773 } 1774 break; 1775 } 1776 } 1777 } 1778 1779 if (Invalid || Init.isInvalid()) 1780 return ExprError(); 1781 1782 // Clear out the expressions within the designation. 1783 Desig.ClearExprs(*this); 1784 1785 DesignatedInitExpr *DIE 1786 = DesignatedInitExpr::Create(Context, 1787 Designators.data(), Designators.size(), 1788 InitExpressions.data(), InitExpressions.size(), 1789 Loc, GNUSyntax, Init.takeAs<Expr>()); 1790 return Owned(DIE); 1791} 1792 1793bool Sema::CheckInitList(InitListExpr *&InitList, QualType &DeclType) { 1794 InitListChecker CheckInitList(*this, InitList, DeclType); 1795 if (!CheckInitList.HadError()) 1796 InitList = CheckInitList.getFullyStructuredList(); 1797 1798 return CheckInitList.HadError(); 1799} 1800 1801/// \brief Diagnose any semantic errors with value-initialization of 1802/// the given type. 1803/// 1804/// Value-initialization effectively zero-initializes any types 1805/// without user-declared constructors, and calls the default 1806/// constructor for a for any type that has a user-declared 1807/// constructor (C++ [dcl.init]p5). Value-initialization can fail when 1808/// a type with a user-declared constructor does not have an 1809/// accessible, non-deleted default constructor. In C, everything can 1810/// be value-initialized, which corresponds to C's notion of 1811/// initializing objects with static storage duration when no 1812/// initializer is provided for that object. 1813/// 1814/// \returns true if there was an error, false otherwise. 1815bool Sema::CheckValueInitialization(QualType Type, SourceLocation Loc) { 1816 // C++ [dcl.init]p5: 1817 // 1818 // To value-initialize an object of type T means: 1819 1820 // -- if T is an array type, then each element is value-initialized; 1821 if (const ArrayType *AT = Context.getAsArrayType(Type)) 1822 return CheckValueInitialization(AT->getElementType(), Loc); 1823 1824 if (const RecordType *RT = Type->getAs<RecordType>()) { 1825 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 1826 // -- if T is a class type (clause 9) with a user-declared 1827 // constructor (12.1), then the default constructor for T is 1828 // called (and the initialization is ill-formed if T has no 1829 // accessible default constructor); 1830 if (ClassDecl->hasUserDeclaredConstructor()) { 1831 ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this); 1832 1833 CXXConstructorDecl *Constructor 1834 = PerformInitializationByConstructor(Type, 1835 MultiExprArg(*this, 0, 0), 1836 Loc, SourceRange(Loc), 1837 DeclarationName(), 1838 IK_Direct, 1839 ConstructorArgs); 1840 if (!Constructor) 1841 return true; 1842 1843 OwningExprResult Init 1844 = BuildCXXConstructExpr(Loc, Type, Constructor, 1845 move_arg(ConstructorArgs)); 1846 if (Init.isInvalid()) 1847 return true; 1848 1849 // FIXME: Actually perform the value-initialization! 1850 return false; 1851 } 1852 } 1853 } 1854 1855 if (Type->isReferenceType()) { 1856 // C++ [dcl.init]p5: 1857 // [...] A program that calls for default-initialization or 1858 // value-initialization of an entity of reference type is 1859 // ill-formed. [...] 1860 // FIXME: Once we have code that goes through this path, add an actual 1861 // diagnostic :) 1862 } 1863 1864 return false; 1865} 1866