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