1 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
14 // This file also implements Sema::CheckInitializerTypes.
16 //===----------------------------------------------------------------------===//
19 #include "clang/Parse/Designator.h"
20 #include "clang/AST/ASTContext.h"
21 #include "clang/AST/ExprCXX.h"
22 #include "clang/AST/ExprObjC.h"
24 using namespace clang
;
26 //===----------------------------------------------------------------------===//
27 // Sema Initialization Checking
28 //===----------------------------------------------------------------------===//
30 static Expr
*IsStringInit(Expr
*Init
, QualType DeclType
, ASTContext
&Context
) {
31 const ArrayType
*AT
= Context
.getAsArrayType(DeclType
);
34 if (!isa
<ConstantArrayType
>(AT
) && !isa
<IncompleteArrayType
>(AT
))
37 // See if this is a string literal or @encode.
38 Init
= Init
->IgnoreParens();
40 // Handle @encode, which is a narrow string.
41 if (isa
<ObjCEncodeExpr
>(Init
) && AT
->getElementType()->isCharType())
44 // Otherwise we can only handle string literals.
45 StringLiteral
*SL
= dyn_cast
<StringLiteral
>(Init
);
46 if (SL
== 0) return 0;
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";
52 return ElemTy
->isCharType() ? Init
: 0;
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()))
65 static 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();
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();
81 Sema::AssignConvertType ConvTy
=
82 S
.CheckSingleAssignmentConstraints(DeclType
, Init
);
83 return S
.DiagnoseAssignmentResult(ConvTy
, Init
->getLocStart(), DeclType
,
84 InitType
, Init
, "initializing");
87 static void CheckStringInit(Expr
*Str
, QualType
&DeclT
, Sema
&S
) {
88 // Get the length of the string as parsed.
90 cast
<ConstantArrayType
>(Str
->getType())->getSize().getZExtValue();
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);
99 // Return a new array type (C99 6.7.8p22).
100 DeclT
= S
.Context
.getConstantArrayWithoutExprType(IAT
->getElementType(),
102 ArrayType::Normal
, 0);
106 const ConstantArrayType
*CAT
= cast
<ConstantArrayType
>(AT
);
108 // C99 6.7.8p14. We have an array of character type with known size. However,
109 // the size may be smaller or larger than the string we are initializing.
110 // FIXME: Avoid truncation for 64-bit length strings.
111 if (StrLength
-1 > CAT
->getSize().getZExtValue())
112 S
.Diag(Str
->getSourceRange().getBegin(),
113 diag::warn_initializer_string_for_char_array_too_long
)
114 << Str
->getSourceRange();
116 // Set the type to the actual size that we are initializing. If we have
118 // char x[1] = "foo";
119 // then this will set the string literal's type to char[1].
123 bool Sema::CheckInitializerTypes(Expr
*&Init
, QualType
&DeclType
,
124 SourceLocation InitLoc
,
125 DeclarationName InitEntity
, bool DirectInit
) {
126 if (DeclType
->isDependentType() ||
127 Init
->isTypeDependent() || Init
->isValueDependent())
130 // C++ [dcl.init.ref]p1:
131 // A variable declared to be a T& or T&&, that is "reference to type T"
132 // (8.3.2), shall be initialized by an object, or function, of
133 // type T or by an object that can be converted into a T.
134 if (DeclType
->isReferenceType())
135 return CheckReferenceInit(Init
, DeclType
, 0, false, DirectInit
);
137 // C99 6.7.8p3: The type of the entity to be initialized shall be an array
138 // of unknown size ("[]") or an object type that is not a variable array type.
139 if (const VariableArrayType
*VAT
= Context
.getAsVariableArrayType(DeclType
))
140 return Diag(InitLoc
, diag::err_variable_object_no_init
)
141 << VAT
->getSizeExpr()->getSourceRange();
143 InitListExpr
*InitList
= dyn_cast
<InitListExpr
>(Init
);
145 // FIXME: Handle wide strings
146 if (Expr
*Str
= IsStringInit(Init
, DeclType
, Context
)) {
147 CheckStringInit(Str
, DeclType
, *this);
151 // C++ [dcl.init]p14:
152 // -- If the destination type is a (possibly cv-qualified) class
154 if (getLangOptions().CPlusPlus
&& DeclType
->isRecordType()) {
155 QualType DeclTypeC
= Context
.getCanonicalType(DeclType
);
156 QualType InitTypeC
= Context
.getCanonicalType(Init
->getType());
158 // -- If the initialization is direct-initialization, or if it is
159 // copy-initialization where the cv-unqualified version of the
160 // source type is the same class as, or a derived class of, the
161 // class of the destination, constructors are considered.
162 if ((DeclTypeC
.getUnqualifiedType() == InitTypeC
.getUnqualifiedType()) ||
163 IsDerivedFrom(InitTypeC
, DeclTypeC
)) {
164 const CXXRecordDecl
*RD
=
165 cast
<CXXRecordDecl
>(DeclType
->getAsRecordType()->getDecl());
167 // No need to make a CXXConstructExpr if both the ctor and dtor are
169 if (RD
->hasTrivialConstructor() && RD
->hasTrivialDestructor())
172 CXXConstructorDecl
*Constructor
173 = PerformInitializationByConstructor(DeclType
, &Init
, 1,
174 InitLoc
, Init
->getSourceRange(),
176 DirectInit
? IK_Direct
: IK_Copy
);
180 Init
= CXXConstructExpr::Create(Context
, DeclType
, Constructor
, false,
185 // -- Otherwise (i.e., for the remaining copy-initialization
186 // cases), user-defined conversion sequences that can
187 // convert from the source type to the destination type or
188 // (when a conversion function is used) to a derived class
189 // thereof are enumerated as described in 13.3.1.4, and the
190 // best one is chosen through overload resolution
191 // (13.3). If the conversion cannot be done or is
192 // ambiguous, the initialization is ill-formed. The
193 // function selected is called with the initializer
194 // expression as its argument; if the function is a
195 // constructor, the call initializes a temporary of the
197 // FIXME: We're pretending to do copy elision here; return to this when we
198 // have ASTs for such things.
199 if (!PerformImplicitConversion(Init
, DeclType
, "initializing"))
203 return Diag(InitLoc
, diag::err_cannot_initialize_decl
)
204 << InitEntity
<< (int)(Init
->isLvalue(Context
) == Expr::LV_Valid
)
205 << Init
->getType() << Init
->getSourceRange();
206 return Diag(InitLoc
, diag::err_cannot_initialize_decl_noname
)
207 << DeclType
<< (int)(Init
->isLvalue(Context
) == Expr::LV_Valid
)
208 << Init
->getType() << Init
->getSourceRange();
212 if (DeclType
->isArrayType())
213 return Diag(Init
->getLocStart(), diag::err_array_init_list_required
)
214 << Init
->getSourceRange();
216 return CheckSingleInitializer(Init
, DeclType
, DirectInit
, *this);
219 bool hadError
= CheckInitList(InitList
, DeclType
);
224 //===----------------------------------------------------------------------===//
225 // Semantic checking for initializer lists.
226 //===----------------------------------------------------------------------===//
228 /// @brief Semantic checking for initializer lists.
230 /// The InitListChecker class contains a set of routines that each
231 /// handle the initialization of a certain kind of entity, e.g.,
232 /// arrays, vectors, struct/union types, scalars, etc. The
233 /// InitListChecker itself performs a recursive walk of the subobject
234 /// structure of the type to be initialized, while stepping through
235 /// the initializer list one element at a time. The IList and Index
236 /// parameters to each of the Check* routines contain the active
237 /// (syntactic) initializer list and the index into that initializer
238 /// list that represents the current initializer. Each routine is
239 /// responsible for moving that Index forward as it consumes elements.
241 /// Each Check* routine also has a StructuredList/StructuredIndex
242 /// arguments, which contains the current the "structured" (semantic)
243 /// initializer list and the index into that initializer list where we
244 /// are copying initializers as we map them over to the semantic
245 /// list. Once we have completed our recursive walk of the subobject
246 /// structure, we will have constructed a full semantic initializer
249 /// C99 designators cause changes in the initializer list traversal,
250 /// because they make the initialization "jump" into a specific
251 /// subobject and then continue the initialization from that
252 /// point. CheckDesignatedInitializer() recursively steps into the
253 /// designated subobject and manages backing out the recursion to
254 /// initialize the subobjects after the one designated.
256 class InitListChecker
{
259 std::map
<InitListExpr
*, InitListExpr
*> SyntacticToSemantic
;
260 InitListExpr
*FullyStructuredList
;
262 void CheckImplicitInitList(InitListExpr
*ParentIList
, QualType T
,
263 unsigned &Index
, InitListExpr
*StructuredList
,
264 unsigned &StructuredIndex
,
265 bool TopLevelObject
= false);
266 void CheckExplicitInitList(InitListExpr
*IList
, QualType
&T
,
267 unsigned &Index
, InitListExpr
*StructuredList
,
268 unsigned &StructuredIndex
,
269 bool TopLevelObject
= false);
270 void CheckListElementTypes(InitListExpr
*IList
, QualType
&DeclType
,
271 bool SubobjectIsDesignatorContext
,
273 InitListExpr
*StructuredList
,
274 unsigned &StructuredIndex
,
275 bool TopLevelObject
= false);
276 void CheckSubElementType(InitListExpr
*IList
, QualType ElemType
,
278 InitListExpr
*StructuredList
,
279 unsigned &StructuredIndex
);
280 void CheckScalarType(InitListExpr
*IList
, QualType DeclType
,
282 InitListExpr
*StructuredList
,
283 unsigned &StructuredIndex
);
284 void CheckReferenceType(InitListExpr
*IList
, QualType DeclType
,
286 InitListExpr
*StructuredList
,
287 unsigned &StructuredIndex
);
288 void CheckVectorType(InitListExpr
*IList
, QualType DeclType
, unsigned &Index
,
289 InitListExpr
*StructuredList
,
290 unsigned &StructuredIndex
);
291 void CheckStructUnionTypes(InitListExpr
*IList
, QualType DeclType
,
292 RecordDecl::field_iterator Field
,
293 bool SubobjectIsDesignatorContext
, unsigned &Index
,
294 InitListExpr
*StructuredList
,
295 unsigned &StructuredIndex
,
296 bool TopLevelObject
= false);
297 void CheckArrayType(InitListExpr
*IList
, QualType
&DeclType
,
298 llvm::APSInt elementIndex
,
299 bool SubobjectIsDesignatorContext
, unsigned &Index
,
300 InitListExpr
*StructuredList
,
301 unsigned &StructuredIndex
);
302 bool CheckDesignatedInitializer(InitListExpr
*IList
, DesignatedInitExpr
*DIE
,
304 QualType
&CurrentObjectType
,
305 RecordDecl::field_iterator
*NextField
,
306 llvm::APSInt
*NextElementIndex
,
308 InitListExpr
*StructuredList
,
309 unsigned &StructuredIndex
,
310 bool FinishSubobjectInit
,
311 bool TopLevelObject
);
312 InitListExpr
*getStructuredSubobjectInit(InitListExpr
*IList
, unsigned Index
,
313 QualType CurrentObjectType
,
314 InitListExpr
*StructuredList
,
315 unsigned StructuredIndex
,
316 SourceRange InitRange
);
317 void UpdateStructuredListElement(InitListExpr
*StructuredList
,
318 unsigned &StructuredIndex
,
320 int numArrayElements(QualType DeclType
);
321 int numStructUnionElements(QualType DeclType
);
323 void FillInValueInitializations(InitListExpr
*ILE
);
325 InitListChecker(Sema
&S
, InitListExpr
*IL
, QualType
&T
);
326 bool HadError() { return hadError
; }
328 // @brief Retrieves the fully-structured initializer list used for
329 // semantic analysis and code generation.
330 InitListExpr
*getFullyStructuredList() const { return FullyStructuredList
; }
332 } // end anonymous namespace
334 /// Recursively replaces NULL values within the given initializer list
335 /// with expressions that perform value-initialization of the
336 /// appropriate type.
337 void InitListChecker::FillInValueInitializations(InitListExpr
*ILE
) {
338 assert((ILE
->getType() != SemaRef
.Context
.VoidTy
) &&
339 "Should not have void type");
340 SourceLocation Loc
= ILE
->getSourceRange().getBegin();
341 if (ILE
->getSyntacticForm())
342 Loc
= ILE
->getSyntacticForm()->getSourceRange().getBegin();
344 if (const RecordType
*RType
= ILE
->getType()->getAsRecordType()) {
345 unsigned Init
= 0, NumInits
= ILE
->getNumInits();
346 for (RecordDecl::field_iterator
347 Field
= RType
->getDecl()->field_begin(),
348 FieldEnd
= RType
->getDecl()->field_end();
349 Field
!= FieldEnd
; ++Field
) {
350 if (Field
->isUnnamedBitfield())
353 if (Init
>= NumInits
|| !ILE
->getInit(Init
)) {
354 if (Field
->getType()->isReferenceType()) {
355 // C++ [dcl.init.aggr]p9:
356 // If an incomplete or empty initializer-list leaves a
357 // member of reference type uninitialized, the program is
359 SemaRef
.Diag(Loc
, diag::err_init_reference_member_uninitialized
)
361 << ILE
->getSyntacticForm()->getSourceRange();
362 SemaRef
.Diag(Field
->getLocation(),
363 diag::note_uninit_reference_member
);
366 } else if (SemaRef
.CheckValueInitialization(Field
->getType(), Loc
)) {
371 // FIXME: If value-initialization involves calling a constructor, should
372 // we make that call explicit in the representation (even when it means
373 // extending the initializer list)?
374 if (Init
< NumInits
&& !hadError
)
376 new (SemaRef
.Context
) ImplicitValueInitExpr(Field
->getType()));
377 } else if (InitListExpr
*InnerILE
378 = dyn_cast
<InitListExpr
>(ILE
->getInit(Init
)))
379 FillInValueInitializations(InnerILE
);
382 // Only look at the first initialization of a union.
383 if (RType
->getDecl()->isUnion())
390 QualType ElementType
;
392 unsigned NumInits
= ILE
->getNumInits();
393 unsigned NumElements
= NumInits
;
394 if (const ArrayType
*AType
= SemaRef
.Context
.getAsArrayType(ILE
->getType())) {
395 ElementType
= AType
->getElementType();
396 if (const ConstantArrayType
*CAType
= dyn_cast
<ConstantArrayType
>(AType
))
397 NumElements
= CAType
->getSize().getZExtValue();
398 } else if (const VectorType
*VType
= ILE
->getType()->getAsVectorType()) {
399 ElementType
= VType
->getElementType();
400 NumElements
= VType
->getNumElements();
402 ElementType
= ILE
->getType();
404 for (unsigned Init
= 0; Init
!= NumElements
; ++Init
) {
405 if (Init
>= NumInits
|| !ILE
->getInit(Init
)) {
406 if (SemaRef
.CheckValueInitialization(ElementType
, Loc
)) {
411 // FIXME: If value-initialization involves calling a constructor, should
412 // we make that call explicit in the representation (even when it means
413 // extending the initializer list)?
414 if (Init
< NumInits
&& !hadError
)
416 new (SemaRef
.Context
) ImplicitValueInitExpr(ElementType
));
418 else if (InitListExpr
*InnerILE
=dyn_cast
<InitListExpr
>(ILE
->getInit(Init
)))
419 FillInValueInitializations(InnerILE
);
424 InitListChecker::InitListChecker(Sema
&S
, InitListExpr
*IL
, QualType
&T
)
428 unsigned newIndex
= 0;
429 unsigned newStructuredIndex
= 0;
431 = getStructuredSubobjectInit(IL
, newIndex
, T
, 0, 0, IL
->getSourceRange());
432 CheckExplicitInitList(IL
, T
, newIndex
, FullyStructuredList
, newStructuredIndex
,
433 /*TopLevelObject=*/true);
436 FillInValueInitializations(FullyStructuredList
);
439 int InitListChecker::numArrayElements(QualType DeclType
) {
440 // FIXME: use a proper constant
441 int maxElements
= 0x7FFFFFFF;
442 if (const ConstantArrayType
*CAT
=
443 SemaRef
.Context
.getAsConstantArrayType(DeclType
)) {
444 maxElements
= static_cast<int>(CAT
->getSize().getZExtValue());
449 int InitListChecker::numStructUnionElements(QualType DeclType
) {
450 RecordDecl
*structDecl
= DeclType
->getAsRecordType()->getDecl();
451 int InitializableMembers
= 0;
452 for (RecordDecl::field_iterator
453 Field
= structDecl
->field_begin(),
454 FieldEnd
= structDecl
->field_end();
455 Field
!= FieldEnd
; ++Field
) {
456 if ((*Field
)->getIdentifier() || !(*Field
)->isBitField())
457 ++InitializableMembers
;
459 if (structDecl
->isUnion())
460 return std::min(InitializableMembers
, 1);
461 return InitializableMembers
- structDecl
->hasFlexibleArrayMember();
464 void InitListChecker::CheckImplicitInitList(InitListExpr
*ParentIList
,
465 QualType T
, unsigned &Index
,
466 InitListExpr
*StructuredList
,
467 unsigned &StructuredIndex
,
468 bool TopLevelObject
) {
471 if (T
->isArrayType())
472 maxElements
= numArrayElements(T
);
473 else if (T
->isStructureType() || T
->isUnionType())
474 maxElements
= numStructUnionElements(T
);
475 else if (T
->isVectorType())
476 maxElements
= T
->getAsVectorType()->getNumElements();
478 assert(0 && "CheckImplicitInitList(): Illegal type");
480 if (maxElements
== 0) {
481 SemaRef
.Diag(ParentIList
->getInit(Index
)->getLocStart(),
482 diag::err_implicit_empty_initializer
);
488 // Build a structured initializer list corresponding to this subobject.
489 InitListExpr
*StructuredSubobjectInitList
490 = getStructuredSubobjectInit(ParentIList
, Index
, T
, StructuredList
,
492 SourceRange(ParentIList
->getInit(Index
)->getSourceRange().getBegin(),
493 ParentIList
->getSourceRange().getEnd()));
494 unsigned StructuredSubobjectInitIndex
= 0;
496 // Check the element types and build the structural subobject.
497 unsigned StartIndex
= Index
;
498 CheckListElementTypes(ParentIList
, T
, false, Index
,
499 StructuredSubobjectInitList
,
500 StructuredSubobjectInitIndex
,
502 unsigned EndIndex
= (Index
== StartIndex
? StartIndex
: Index
- 1);
503 StructuredSubobjectInitList
->setType(T
);
505 // Update the structured sub-object initializer so that it's ending
506 // range corresponds with the end of the last initializer it used.
507 if (EndIndex
< ParentIList
->getNumInits()) {
508 SourceLocation EndLoc
509 = ParentIList
->getInit(EndIndex
)->getSourceRange().getEnd();
510 StructuredSubobjectInitList
->setRBraceLoc(EndLoc
);
514 void InitListChecker::CheckExplicitInitList(InitListExpr
*IList
, QualType
&T
,
516 InitListExpr
*StructuredList
,
517 unsigned &StructuredIndex
,
518 bool TopLevelObject
) {
519 assert(IList
->isExplicit() && "Illegal Implicit InitListExpr");
520 SyntacticToSemantic
[IList
] = StructuredList
;
521 StructuredList
->setSyntacticForm(IList
);
522 CheckListElementTypes(IList
, T
, true, Index
, StructuredList
,
523 StructuredIndex
, TopLevelObject
);
525 StructuredList
->setType(T
);
529 if (Index
< IList
->getNumInits()) {
530 // We have leftover initializers
531 if (StructuredIndex
== 1 &&
532 IsStringInit(StructuredList
->getInit(0), T
, SemaRef
.Context
)) {
533 unsigned DK
= diag::warn_excess_initializers_in_char_array_initializer
;
534 if (SemaRef
.getLangOptions().CPlusPlus
) {
535 DK
= diag::err_excess_initializers_in_char_array_initializer
;
539 SemaRef
.Diag(IList
->getInit(Index
)->getLocStart(), DK
)
540 << IList
->getInit(Index
)->getSourceRange();
541 } else if (!T
->isIncompleteType()) {
542 // Don't complain for incomplete types, since we'll get an error
544 QualType CurrentObjectType
= StructuredList
->getType();
546 CurrentObjectType
->isArrayType()? 0 :
547 CurrentObjectType
->isVectorType()? 1 :
548 CurrentObjectType
->isScalarType()? 2 :
549 CurrentObjectType
->isUnionType()? 3 :
552 unsigned DK
= diag::warn_excess_initializers
;
553 if (SemaRef
.getLangOptions().CPlusPlus
) {
554 DK
= diag::err_excess_initializers
;
557 if (SemaRef
.getLangOptions().OpenCL
&& initKind
== 1) {
558 DK
= diag::err_excess_initializers
;
562 SemaRef
.Diag(IList
->getInit(Index
)->getLocStart(), DK
)
563 << initKind
<< IList
->getInit(Index
)->getSourceRange();
567 if (T
->isScalarType() && !TopLevelObject
)
568 SemaRef
.Diag(IList
->getLocStart(), diag::warn_braces_around_scalar_init
)
569 << IList
->getSourceRange()
570 << CodeModificationHint::CreateRemoval(SourceRange(IList
->getLocStart()))
571 << CodeModificationHint::CreateRemoval(SourceRange(IList
->getLocEnd()));
574 void InitListChecker::CheckListElementTypes(InitListExpr
*IList
,
576 bool SubobjectIsDesignatorContext
,
578 InitListExpr
*StructuredList
,
579 unsigned &StructuredIndex
,
580 bool TopLevelObject
) {
581 if (DeclType
->isScalarType()) {
582 CheckScalarType(IList
, DeclType
, Index
, StructuredList
, StructuredIndex
);
583 } else if (DeclType
->isVectorType()) {
584 CheckVectorType(IList
, DeclType
, Index
, StructuredList
, StructuredIndex
);
585 } else if (DeclType
->isAggregateType()) {
586 if (DeclType
->isRecordType()) {
587 RecordDecl
*RD
= DeclType
->getAsRecordType()->getDecl();
588 CheckStructUnionTypes(IList
, DeclType
, RD
->field_begin(),
589 SubobjectIsDesignatorContext
, Index
,
590 StructuredList
, StructuredIndex
,
592 } else if (DeclType
->isArrayType()) {
594 SemaRef
.Context
.getTypeSize(SemaRef
.Context
.getSizeType()),
596 CheckArrayType(IList
, DeclType
, Zero
, SubobjectIsDesignatorContext
, Index
,
597 StructuredList
, StructuredIndex
);
600 assert(0 && "Aggregate that isn't a structure or array?!");
601 } else if (DeclType
->isVoidType() || DeclType
->isFunctionType()) {
602 // This type is invalid, issue a diagnostic.
604 SemaRef
.Diag(IList
->getLocStart(), diag::err_illegal_initializer_type
)
607 } else if (DeclType
->isRecordType()) {
608 // C++ [dcl.init]p14:
609 // [...] If the class is an aggregate (8.5.1), and the initializer
610 // is a brace-enclosed list, see 8.5.1.
612 // Note: 8.5.1 is handled below; here, we diagnose the case where
613 // we have an initializer list and a destination type that is not
615 // FIXME: In C++0x, this is yet another form of initialization.
616 SemaRef
.Diag(IList
->getLocStart(), diag::err_init_non_aggr_init_list
)
617 << DeclType
<< IList
->getSourceRange();
619 } else if (DeclType
->isReferenceType()) {
620 CheckReferenceType(IList
, DeclType
, Index
, StructuredList
, StructuredIndex
);
622 // In C, all types are either scalars or aggregates, but
623 // additional handling is needed here for C++ (and possibly others?).
624 assert(0 && "Unsupported initializer type");
628 void InitListChecker::CheckSubElementType(InitListExpr
*IList
,
631 InitListExpr
*StructuredList
,
632 unsigned &StructuredIndex
) {
633 Expr
*expr
= IList
->getInit(Index
);
634 if (InitListExpr
*SubInitList
= dyn_cast
<InitListExpr
>(expr
)) {
635 unsigned newIndex
= 0;
636 unsigned newStructuredIndex
= 0;
637 InitListExpr
*newStructuredList
638 = getStructuredSubobjectInit(IList
, Index
, ElemType
,
639 StructuredList
, StructuredIndex
,
640 SubInitList
->getSourceRange());
641 CheckExplicitInitList(SubInitList
, ElemType
, newIndex
,
642 newStructuredList
, newStructuredIndex
);
645 } else if (Expr
*Str
= IsStringInit(expr
, ElemType
, SemaRef
.Context
)) {
646 CheckStringInit(Str
, ElemType
, SemaRef
);
647 UpdateStructuredListElement(StructuredList
, StructuredIndex
, Str
);
649 } else if (ElemType
->isScalarType()) {
650 CheckScalarType(IList
, ElemType
, Index
, StructuredList
, StructuredIndex
);
651 } else if (ElemType
->isReferenceType()) {
652 CheckReferenceType(IList
, ElemType
, Index
, StructuredList
, StructuredIndex
);
654 if (SemaRef
.getLangOptions().CPlusPlus
) {
655 // C++ [dcl.init.aggr]p12:
656 // All implicit type conversions (clause 4) are considered when
657 // initializing the aggregate member with an ini- tializer from
658 // an initializer-list. If the initializer can initialize a
659 // member, the member is initialized. [...]
660 ImplicitConversionSequence ICS
661 = SemaRef
.TryCopyInitialization(expr
, ElemType
);
662 if (ICS
.ConversionKind
!= ImplicitConversionSequence::BadConversion
) {
663 if (SemaRef
.PerformImplicitConversion(expr
, ElemType
, ICS
,
666 UpdateStructuredListElement(StructuredList
, StructuredIndex
, expr
);
671 // Fall through for subaggregate initialization
675 // The initializer for a structure or union object that has
676 // automatic storage duration shall be either an initializer
677 // list as described below, or a single expression that has
678 // compatible structure or union type. In the latter case, the
679 // initial value of the object, including unnamed members, is
680 // that of the expression.
681 if ((ElemType
->isRecordType() || ElemType
->isVectorType()) &&
682 SemaRef
.Context
.hasSameUnqualifiedType(expr
->getType(), ElemType
)) {
683 UpdateStructuredListElement(StructuredList
, StructuredIndex
, expr
);
688 // Fall through for subaggregate initialization
691 // C++ [dcl.init.aggr]p12:
693 // [...] Otherwise, if the member is itself a non-empty
694 // subaggregate, brace elision is assumed and the initializer is
695 // considered for the initialization of the first member of
697 if (ElemType
->isAggregateType() || ElemType
->isVectorType()) {
698 CheckImplicitInitList(IList
, ElemType
, Index
, StructuredList
,
702 // We cannot initialize this element, so let
703 // PerformCopyInitialization produce the appropriate diagnostic.
704 SemaRef
.PerformCopyInitialization(expr
, ElemType
, "initializing");
712 void InitListChecker::CheckScalarType(InitListExpr
*IList
, QualType DeclType
,
714 InitListExpr
*StructuredList
,
715 unsigned &StructuredIndex
) {
716 if (Index
< IList
->getNumInits()) {
717 Expr
*expr
= IList
->getInit(Index
);
718 if (isa
<InitListExpr
>(expr
)) {
719 SemaRef
.Diag(IList
->getLocStart(),
720 diag::err_many_braces_around_scalar_init
)
721 << IList
->getSourceRange();
726 } else if (isa
<DesignatedInitExpr
>(expr
)) {
727 SemaRef
.Diag(expr
->getSourceRange().getBegin(),
728 diag::err_designator_for_scalar_init
)
729 << DeclType
<< expr
->getSourceRange();
736 Expr
*savExpr
= expr
; // Might be promoted by CheckSingleInitializer.
737 if (CheckSingleInitializer(expr
, DeclType
, false, SemaRef
))
738 hadError
= true; // types weren't compatible.
739 else if (savExpr
!= expr
) {
740 // The type was promoted, update initializer list.
741 IList
->setInit(Index
, expr
);
746 UpdateStructuredListElement(StructuredList
, StructuredIndex
, expr
);
749 SemaRef
.Diag(IList
->getLocStart(), diag::err_empty_scalar_initializer
)
750 << IList
->getSourceRange();
758 void InitListChecker::CheckReferenceType(InitListExpr
*IList
, QualType DeclType
,
760 InitListExpr
*StructuredList
,
761 unsigned &StructuredIndex
) {
762 if (Index
< IList
->getNumInits()) {
763 Expr
*expr
= IList
->getInit(Index
);
764 if (isa
<InitListExpr
>(expr
)) {
765 SemaRef
.Diag(IList
->getLocStart(), diag::err_init_non_aggr_init_list
)
766 << DeclType
<< IList
->getSourceRange();
773 Expr
*savExpr
= expr
; // Might be promoted by CheckSingleInitializer.
774 if (SemaRef
.CheckReferenceInit(expr
, DeclType
))
776 else if (savExpr
!= expr
) {
777 // The type was promoted, update initializer list.
778 IList
->setInit(Index
, expr
);
783 UpdateStructuredListElement(StructuredList
, StructuredIndex
, expr
);
786 // FIXME: It would be wonderful if we could point at the actual member. In
787 // general, it would be useful to pass location information down the stack,
788 // so that we know the location (or decl) of the "current object" being
790 SemaRef
.Diag(IList
->getLocStart(),
791 diag::err_init_reference_member_uninitialized
)
793 << IList
->getSourceRange();
801 void InitListChecker::CheckVectorType(InitListExpr
*IList
, QualType DeclType
,
803 InitListExpr
*StructuredList
,
804 unsigned &StructuredIndex
) {
805 if (Index
< IList
->getNumInits()) {
806 const VectorType
*VT
= DeclType
->getAsVectorType();
807 int maxElements
= VT
->getNumElements();
808 QualType elementType
= VT
->getElementType();
810 for (int i
= 0; i
< maxElements
; ++i
) {
811 // Don't attempt to go past the end of the init list
812 if (Index
>= IList
->getNumInits())
814 CheckSubElementType(IList
, elementType
, Index
,
815 StructuredList
, StructuredIndex
);
820 void InitListChecker::CheckArrayType(InitListExpr
*IList
, QualType
&DeclType
,
821 llvm::APSInt elementIndex
,
822 bool SubobjectIsDesignatorContext
,
824 InitListExpr
*StructuredList
,
825 unsigned &StructuredIndex
) {
826 // Check for the special-case of initializing an array with a string.
827 if (Index
< IList
->getNumInits()) {
828 if (Expr
*Str
= IsStringInit(IList
->getInit(Index
), DeclType
,
830 CheckStringInit(Str
, DeclType
, SemaRef
);
831 // We place the string literal directly into the resulting
832 // initializer list. This is the only place where the structure
833 // of the structured initializer list doesn't match exactly,
834 // because doing so would involve allocating one character
835 // constant for each string.
836 UpdateStructuredListElement(StructuredList
, StructuredIndex
, Str
);
837 StructuredList
->resizeInits(SemaRef
.Context
, StructuredIndex
);
842 if (const VariableArrayType
*VAT
=
843 SemaRef
.Context
.getAsVariableArrayType(DeclType
)) {
844 // Check for VLAs; in standard C it would be possible to check this
845 // earlier, but I don't know where clang accepts VLAs (gcc accepts
846 // them in all sorts of strange places).
847 SemaRef
.Diag(VAT
->getSizeExpr()->getLocStart(),
848 diag::err_variable_object_no_init
)
849 << VAT
->getSizeExpr()->getSourceRange();
856 // We might know the maximum number of elements in advance.
857 llvm::APSInt
maxElements(elementIndex
.getBitWidth(),
858 elementIndex
.isUnsigned());
859 bool maxElementsKnown
= false;
860 if (const ConstantArrayType
*CAT
=
861 SemaRef
.Context
.getAsConstantArrayType(DeclType
)) {
862 maxElements
= CAT
->getSize();
863 elementIndex
.extOrTrunc(maxElements
.getBitWidth());
864 elementIndex
.setIsUnsigned(maxElements
.isUnsigned());
865 maxElementsKnown
= true;
868 QualType elementType
= SemaRef
.Context
.getAsArrayType(DeclType
)
870 while (Index
< IList
->getNumInits()) {
871 Expr
*Init
= IList
->getInit(Index
);
872 if (DesignatedInitExpr
*DIE
= dyn_cast
<DesignatedInitExpr
>(Init
)) {
873 // If we're not the subobject that matches up with the '{' for
874 // the designator, we shouldn't be handling the
875 // designator. Return immediately.
876 if (!SubobjectIsDesignatorContext
)
879 // Handle this designated initializer. elementIndex will be
880 // updated to be the next array element we'll initialize.
881 if (CheckDesignatedInitializer(IList
, DIE
, 0,
882 DeclType
, 0, &elementIndex
, Index
,
883 StructuredList
, StructuredIndex
, true,
889 if (elementIndex
.getBitWidth() > maxElements
.getBitWidth())
890 maxElements
.extend(elementIndex
.getBitWidth());
891 else if (elementIndex
.getBitWidth() < maxElements
.getBitWidth())
892 elementIndex
.extend(maxElements
.getBitWidth());
893 elementIndex
.setIsUnsigned(maxElements
.isUnsigned());
895 // If the array is of incomplete type, keep track of the number of
896 // elements in the initializer.
897 if (!maxElementsKnown
&& elementIndex
> maxElements
)
898 maxElements
= elementIndex
;
903 // If we know the maximum number of elements, and we've already
904 // hit it, stop consuming elements in the initializer list.
905 if (maxElementsKnown
&& elementIndex
== maxElements
)
908 // Check this element.
909 CheckSubElementType(IList
, elementType
, Index
,
910 StructuredList
, StructuredIndex
);
913 // If the array is of incomplete type, keep track of the number of
914 // elements in the initializer.
915 if (!maxElementsKnown
&& elementIndex
> maxElements
)
916 maxElements
= elementIndex
;
918 if (!hadError
&& DeclType
->isIncompleteArrayType()) {
919 // If this is an incomplete array type, the actual type needs to
920 // be calculated here.
921 llvm::APSInt
Zero(maxElements
.getBitWidth(), maxElements
.isUnsigned());
922 if (maxElements
== Zero
) {
923 // Sizing an array implicitly to zero is not allowed by ISO C,
924 // but is supported by GNU.
925 SemaRef
.Diag(IList
->getLocStart(),
926 diag::ext_typecheck_zero_array_size
);
929 DeclType
= SemaRef
.Context
.getConstantArrayType(elementType
, maxElements
,
930 ArrayType::Normal
, 0);
934 void InitListChecker::CheckStructUnionTypes(InitListExpr
*IList
,
936 RecordDecl::field_iterator Field
,
937 bool SubobjectIsDesignatorContext
,
939 InitListExpr
*StructuredList
,
940 unsigned &StructuredIndex
,
941 bool TopLevelObject
) {
942 RecordDecl
* structDecl
= DeclType
->getAsRecordType()->getDecl();
944 // If the record is invalid, some of it's members are invalid. To avoid
945 // confusion, we forgo checking the intializer for the entire record.
946 if (structDecl
->isInvalidDecl()) {
951 if (DeclType
->isUnionType() && IList
->getNumInits() == 0) {
952 // Value-initialize the first named member of the union.
953 RecordDecl
*RD
= DeclType
->getAsRecordType()->getDecl();
954 for (RecordDecl::field_iterator FieldEnd
= RD
->field_end();
955 Field
!= FieldEnd
; ++Field
) {
956 if (Field
->getDeclName()) {
957 StructuredList
->setInitializedFieldInUnion(*Field
);
964 // If structDecl is a forward declaration, this loop won't do
965 // anything except look at designated initializers; That's okay,
966 // because an error should get printed out elsewhere. It might be
967 // worthwhile to skip over the rest of the initializer, though.
968 RecordDecl
*RD
= DeclType
->getAsRecordType()->getDecl();
969 RecordDecl::field_iterator FieldEnd
= RD
->field_end();
970 bool InitializedSomething
= false;
971 while (Index
< IList
->getNumInits()) {
972 Expr
*Init
= IList
->getInit(Index
);
974 if (DesignatedInitExpr
*DIE
= dyn_cast
<DesignatedInitExpr
>(Init
)) {
975 // If we're not the subobject that matches up with the '{' for
976 // the designator, we shouldn't be handling the
977 // designator. Return immediately.
978 if (!SubobjectIsDesignatorContext
)
981 // Handle this designated initializer. Field will be updated to
982 // the next field that we'll be initializing.
983 if (CheckDesignatedInitializer(IList
, DIE
, 0,
984 DeclType
, &Field
, 0, Index
,
985 StructuredList
, StructuredIndex
,
986 true, TopLevelObject
))
989 InitializedSomething
= true;
993 if (Field
== FieldEnd
) {
994 // We've run out of fields. We're done.
998 // We've already initialized a member of a union. We're done.
999 if (InitializedSomething
&& DeclType
->isUnionType())
1002 // If we've hit the flexible array member at the end, we're done.
1003 if (Field
->getType()->isIncompleteArrayType())
1006 if (Field
->isUnnamedBitfield()) {
1007 // Don't initialize unnamed bitfields, e.g. "int : 20;"
1012 CheckSubElementType(IList
, Field
->getType(), Index
,
1013 StructuredList
, StructuredIndex
);
1014 InitializedSomething
= true;
1016 if (DeclType
->isUnionType()) {
1017 // Initialize the first field within the union.
1018 StructuredList
->setInitializedFieldInUnion(*Field
);
1024 if (Field
== FieldEnd
|| !Field
->getType()->isIncompleteArrayType() ||
1025 Index
>= IList
->getNumInits())
1028 // Handle GNU flexible array initializers.
1029 if (!TopLevelObject
&&
1030 (!isa
<InitListExpr
>(IList
->getInit(Index
)) ||
1031 cast
<InitListExpr
>(IList
->getInit(Index
))->getNumInits() > 0)) {
1032 SemaRef
.Diag(IList
->getInit(Index
)->getSourceRange().getBegin(),
1033 diag::err_flexible_array_init_nonempty
)
1034 << IList
->getInit(Index
)->getSourceRange().getBegin();
1035 SemaRef
.Diag(Field
->getLocation(), diag::note_flexible_array_member
)
1041 SemaRef
.Diag(IList
->getInit(Index
)->getSourceRange().getBegin(),
1042 diag::ext_flexible_array_init
)
1043 << IList
->getInit(Index
)->getSourceRange().getBegin();
1044 SemaRef
.Diag(Field
->getLocation(), diag::note_flexible_array_member
)
1048 if (isa
<InitListExpr
>(IList
->getInit(Index
)))
1049 CheckSubElementType(IList
, Field
->getType(), Index
, StructuredList
,
1052 CheckImplicitInitList(IList
, Field
->getType(), Index
, StructuredList
,
1056 /// \brief Expand a field designator that refers to a member of an
1057 /// anonymous struct or union into a series of field designators that
1058 /// refers to the field within the appropriate subobject.
1060 /// Field/FieldIndex will be updated to point to the (new)
1061 /// currently-designated field.
1062 static void ExpandAnonymousFieldDesignator(Sema
&SemaRef
,
1063 DesignatedInitExpr
*DIE
,
1066 RecordDecl::field_iterator
&FieldIter
,
1067 unsigned &FieldIndex
) {
1068 typedef DesignatedInitExpr::Designator Designator
;
1070 // Build the path from the current object to the member of the
1071 // anonymous struct/union (backwards).
1072 llvm::SmallVector
<FieldDecl
*, 4> Path
;
1073 SemaRef
.BuildAnonymousStructUnionMemberPath(Field
, Path
);
1075 // Build the replacement designators.
1076 llvm::SmallVector
<Designator
, 4> Replacements
;
1077 for (llvm::SmallVector
<FieldDecl
*, 4>::reverse_iterator
1078 FI
= Path
.rbegin(), FIEnd
= Path
.rend();
1079 FI
!= FIEnd
; ++FI
) {
1080 if (FI
+ 1 == FIEnd
)
1081 Replacements
.push_back(Designator((IdentifierInfo
*)0,
1082 DIE
->getDesignator(DesigIdx
)->getDotLoc(),
1083 DIE
->getDesignator(DesigIdx
)->getFieldLoc()));
1085 Replacements
.push_back(Designator((IdentifierInfo
*)0, SourceLocation(),
1087 Replacements
.back().setField(*FI
);
1090 // Expand the current designator into the set of replacement
1091 // designators, so we have a full subobject path down to where the
1092 // member of the anonymous struct/union is actually stored.
1093 DIE
->ExpandDesignator(DesigIdx
, &Replacements
[0],
1094 &Replacements
[0] + Replacements
.size());
1096 // Update FieldIter/FieldIndex;
1097 RecordDecl
*Record
= cast
<RecordDecl
>(Path
.back()->getDeclContext());
1098 FieldIter
= Record
->field_begin();
1100 for (RecordDecl::field_iterator FEnd
= Record
->field_end();
1101 FieldIter
!= FEnd
; ++FieldIter
) {
1102 if (FieldIter
->isUnnamedBitfield())
1105 if (*FieldIter
== Path
.back())
1111 assert(false && "Unable to find anonymous struct/union field");
1114 /// @brief Check the well-formedness of a C99 designated initializer.
1116 /// Determines whether the designated initializer @p DIE, which
1117 /// resides at the given @p Index within the initializer list @p
1118 /// IList, is well-formed for a current object of type @p DeclType
1119 /// (C99 6.7.8). The actual subobject that this designator refers to
1120 /// within the current subobject is returned in either
1121 /// @p NextField or @p NextElementIndex (whichever is appropriate).
1123 /// @param IList The initializer list in which this designated
1124 /// initializer occurs.
1126 /// @param DIE The designated initializer expression.
1128 /// @param DesigIdx The index of the current designator.
1130 /// @param DeclType The type of the "current object" (C99 6.7.8p17),
1131 /// into which the designation in @p DIE should refer.
1133 /// @param NextField If non-NULL and the first designator in @p DIE is
1134 /// a field, this will be set to the field declaration corresponding
1135 /// to the field named by the designator.
1137 /// @param NextElementIndex If non-NULL and the first designator in @p
1138 /// DIE is an array designator or GNU array-range designator, this
1139 /// will be set to the last index initialized by this designator.
1141 /// @param Index Index into @p IList where the designated initializer
1144 /// @param StructuredList The initializer list expression that
1145 /// describes all of the subobject initializers in the order they'll
1146 /// actually be initialized.
1148 /// @returns true if there was an error, false otherwise.
1150 InitListChecker::CheckDesignatedInitializer(InitListExpr
*IList
,
1151 DesignatedInitExpr
*DIE
,
1153 QualType
&CurrentObjectType
,
1154 RecordDecl::field_iterator
*NextField
,
1155 llvm::APSInt
*NextElementIndex
,
1157 InitListExpr
*StructuredList
,
1158 unsigned &StructuredIndex
,
1159 bool FinishSubobjectInit
,
1160 bool TopLevelObject
) {
1161 if (DesigIdx
== DIE
->size()) {
1162 // Check the actual initialization for the designated object type.
1163 bool prevHadError
= hadError
;
1165 // Temporarily remove the designator expression from the
1166 // initializer list that the child calls see, so that we don't try
1167 // to re-process the designator.
1168 unsigned OldIndex
= Index
;
1169 IList
->setInit(OldIndex
, DIE
->getInit());
1171 CheckSubElementType(IList
, CurrentObjectType
, Index
,
1172 StructuredList
, StructuredIndex
);
1174 // Restore the designated initializer expression in the syntactic
1175 // form of the initializer list.
1176 if (IList
->getInit(OldIndex
) != DIE
->getInit())
1177 DIE
->setInit(IList
->getInit(OldIndex
));
1178 IList
->setInit(OldIndex
, DIE
);
1180 return hadError
&& !prevHadError
;
1183 bool IsFirstDesignator
= (DesigIdx
== 0);
1184 assert((IsFirstDesignator
|| StructuredList
) &&
1185 "Need a non-designated initializer list to start from");
1187 DesignatedInitExpr::Designator
*D
= DIE
->getDesignator(DesigIdx
);
1188 // Determine the structural initializer list that corresponds to the
1189 // current subobject.
1190 StructuredList
= IsFirstDesignator
? SyntacticToSemantic
[IList
]
1191 : getStructuredSubobjectInit(IList
, Index
, CurrentObjectType
,
1192 StructuredList
, StructuredIndex
,
1193 SourceRange(D
->getStartLocation(),
1194 DIE
->getSourceRange().getEnd()));
1195 assert(StructuredList
&& "Expected a structured initializer list");
1197 if (D
->isFieldDesignator()) {
1200 // If a designator has the form
1204 // then the current object (defined below) shall have
1205 // structure or union type and the identifier shall be the
1206 // name of a member of that type.
1207 const RecordType
*RT
= CurrentObjectType
->getAsRecordType();
1209 SourceLocation Loc
= D
->getDotLoc();
1210 if (Loc
.isInvalid())
1211 Loc
= D
->getFieldLoc();
1212 SemaRef
.Diag(Loc
, diag::err_field_designator_non_aggr
)
1213 << SemaRef
.getLangOptions().CPlusPlus
<< CurrentObjectType
;
1218 // Note: we perform a linear search of the fields here, despite
1219 // the fact that we have a faster lookup method, because we always
1220 // need to compute the field's index.
1221 FieldDecl
*KnownField
= D
->getField();
1222 IdentifierInfo
*FieldName
= D
->getFieldName();
1223 unsigned FieldIndex
= 0;
1224 RecordDecl::field_iterator
1225 Field
= RT
->getDecl()->field_begin(),
1226 FieldEnd
= RT
->getDecl()->field_end();
1227 for (; Field
!= FieldEnd
; ++Field
) {
1228 if (Field
->isUnnamedBitfield())
1231 if (KnownField
== *Field
|| Field
->getIdentifier() == FieldName
)
1237 if (Field
== FieldEnd
) {
1238 // There was no normal field in the struct with the designated
1239 // name. Perform another lookup for this name, which may find
1240 // something that we can't designate (e.g., a member function),
1241 // may find nothing, or may find a member of an anonymous
1243 DeclContext::lookup_result Lookup
= RT
->getDecl()->lookup(FieldName
);
1244 if (Lookup
.first
== Lookup
.second
) {
1245 // Name lookup didn't find anything.
1246 SemaRef
.Diag(D
->getFieldLoc(), diag::err_field_designator_unknown
)
1247 << FieldName
<< CurrentObjectType
;
1250 } else if (!KnownField
&& isa
<FieldDecl
>(*Lookup
.first
) &&
1251 cast
<RecordDecl
>((*Lookup
.first
)->getDeclContext())
1252 ->isAnonymousStructOrUnion()) {
1253 // Handle an field designator that refers to a member of an
1254 // anonymous struct or union.
1255 ExpandAnonymousFieldDesignator(SemaRef
, DIE
, DesigIdx
,
1256 cast
<FieldDecl
>(*Lookup
.first
),
1258 D
= DIE
->getDesignator(DesigIdx
);
1260 // Name lookup found something, but it wasn't a field.
1261 SemaRef
.Diag(D
->getFieldLoc(), diag::err_field_designator_nonfield
)
1263 SemaRef
.Diag((*Lookup
.first
)->getLocation(),
1264 diag::note_field_designator_found
);
1268 } else if (!KnownField
&&
1269 cast
<RecordDecl
>((*Field
)->getDeclContext())
1270 ->isAnonymousStructOrUnion()) {
1271 ExpandAnonymousFieldDesignator(SemaRef
, DIE
, DesigIdx
, *Field
,
1273 D
= DIE
->getDesignator(DesigIdx
);
1276 // All of the fields of a union are located at the same place in
1277 // the initializer list.
1278 if (RT
->getDecl()->isUnion()) {
1280 StructuredList
->setInitializedFieldInUnion(*Field
);
1283 // Update the designator with the field declaration.
1284 D
->setField(*Field
);
1286 // Make sure that our non-designated initializer list has space
1287 // for a subobject corresponding to this field.
1288 if (FieldIndex
>= StructuredList
->getNumInits())
1289 StructuredList
->resizeInits(SemaRef
.Context
, FieldIndex
+ 1);
1291 // This designator names a flexible array member.
1292 if (Field
->getType()->isIncompleteArrayType()) {
1293 bool Invalid
= false;
1294 if ((DesigIdx
+ 1) != DIE
->size()) {
1295 // We can't designate an object within the flexible array
1296 // member (because GCC doesn't allow it).
1297 DesignatedInitExpr::Designator
*NextD
1298 = DIE
->getDesignator(DesigIdx
+ 1);
1299 SemaRef
.Diag(NextD
->getStartLocation(),
1300 diag::err_designator_into_flexible_array_member
)
1301 << SourceRange(NextD
->getStartLocation(),
1302 DIE
->getSourceRange().getEnd());
1303 SemaRef
.Diag(Field
->getLocation(), diag::note_flexible_array_member
)
1308 if (!hadError
&& !isa
<InitListExpr
>(DIE
->getInit())) {
1309 // The initializer is not an initializer list.
1310 SemaRef
.Diag(DIE
->getInit()->getSourceRange().getBegin(),
1311 diag::err_flexible_array_init_needs_braces
)
1312 << DIE
->getInit()->getSourceRange();
1313 SemaRef
.Diag(Field
->getLocation(), diag::note_flexible_array_member
)
1318 // Handle GNU flexible array initializers.
1319 if (!Invalid
&& !TopLevelObject
&&
1320 cast
<InitListExpr
>(DIE
->getInit())->getNumInits() > 0) {
1321 SemaRef
.Diag(DIE
->getSourceRange().getBegin(),
1322 diag::err_flexible_array_init_nonempty
)
1323 << DIE
->getSourceRange().getBegin();
1324 SemaRef
.Diag(Field
->getLocation(), diag::note_flexible_array_member
)
1334 // Initialize the array.
1335 bool prevHadError
= hadError
;
1336 unsigned newStructuredIndex
= FieldIndex
;
1337 unsigned OldIndex
= Index
;
1338 IList
->setInit(Index
, DIE
->getInit());
1339 CheckSubElementType(IList
, Field
->getType(), Index
,
1340 StructuredList
, newStructuredIndex
);
1341 IList
->setInit(OldIndex
, DIE
);
1342 if (hadError
&& !prevHadError
) {
1347 StructuredIndex
= FieldIndex
;
1351 // Recurse to check later designated subobjects.
1352 QualType FieldType
= (*Field
)->getType();
1353 unsigned newStructuredIndex
= FieldIndex
;
1354 if (CheckDesignatedInitializer(IList
, DIE
, DesigIdx
+ 1, FieldType
, 0, 0,
1355 Index
, StructuredList
, newStructuredIndex
,
1360 // Find the position of the next field to be initialized in this
1365 // If this the first designator, our caller will continue checking
1366 // the rest of this struct/class/union subobject.
1367 if (IsFirstDesignator
) {
1370 StructuredIndex
= FieldIndex
;
1374 if (!FinishSubobjectInit
)
1377 // We've already initialized something in the union; we're done.
1378 if (RT
->getDecl()->isUnion())
1381 // Check the remaining fields within this class/struct/union subobject.
1382 bool prevHadError
= hadError
;
1383 CheckStructUnionTypes(IList
, CurrentObjectType
, Field
, false, Index
,
1384 StructuredList
, FieldIndex
);
1385 return hadError
&& !prevHadError
;
1390 // If a designator has the form
1392 // [ constant-expression ]
1394 // then the current object (defined below) shall have array
1395 // type and the expression shall be an integer constant
1396 // expression. If the array is of unknown size, any
1397 // nonnegative value is valid.
1399 // Additionally, cope with the GNU extension that permits
1400 // designators of the form
1402 // [ constant-expression ... constant-expression ]
1403 const ArrayType
*AT
= SemaRef
.Context
.getAsArrayType(CurrentObjectType
);
1405 SemaRef
.Diag(D
->getLBracketLoc(), diag::err_array_designator_non_array
)
1406 << CurrentObjectType
;
1411 Expr
*IndexExpr
= 0;
1412 llvm::APSInt DesignatedStartIndex
, DesignatedEndIndex
;
1413 if (D
->isArrayDesignator()) {
1414 IndexExpr
= DIE
->getArrayIndex(*D
);
1415 DesignatedStartIndex
= IndexExpr
->EvaluateAsInt(SemaRef
.Context
);
1416 DesignatedEndIndex
= DesignatedStartIndex
;
1418 assert(D
->isArrayRangeDesignator() && "Need array-range designator");
1421 DesignatedStartIndex
=
1422 DIE
->getArrayRangeStart(*D
)->EvaluateAsInt(SemaRef
.Context
);
1423 DesignatedEndIndex
=
1424 DIE
->getArrayRangeEnd(*D
)->EvaluateAsInt(SemaRef
.Context
);
1425 IndexExpr
= DIE
->getArrayRangeEnd(*D
);
1427 if (DesignatedStartIndex
.getZExtValue() !=DesignatedEndIndex
.getZExtValue())
1428 FullyStructuredList
->sawArrayRangeDesignator();
1431 if (isa
<ConstantArrayType
>(AT
)) {
1432 llvm::APSInt
MaxElements(cast
<ConstantArrayType
>(AT
)->getSize(), false);
1433 DesignatedStartIndex
.extOrTrunc(MaxElements
.getBitWidth());
1434 DesignatedStartIndex
.setIsUnsigned(MaxElements
.isUnsigned());
1435 DesignatedEndIndex
.extOrTrunc(MaxElements
.getBitWidth());
1436 DesignatedEndIndex
.setIsUnsigned(MaxElements
.isUnsigned());
1437 if (DesignatedEndIndex
>= MaxElements
) {
1438 SemaRef
.Diag(IndexExpr
->getSourceRange().getBegin(),
1439 diag::err_array_designator_too_large
)
1440 << DesignatedEndIndex
.toString(10) << MaxElements
.toString(10)
1441 << IndexExpr
->getSourceRange();
1446 // Make sure the bit-widths and signedness match.
1447 if (DesignatedStartIndex
.getBitWidth() > DesignatedEndIndex
.getBitWidth())
1448 DesignatedEndIndex
.extend(DesignatedStartIndex
.getBitWidth());
1449 else if (DesignatedStartIndex
.getBitWidth() <
1450 DesignatedEndIndex
.getBitWidth())
1451 DesignatedStartIndex
.extend(DesignatedEndIndex
.getBitWidth());
1452 DesignatedStartIndex
.setIsUnsigned(true);
1453 DesignatedEndIndex
.setIsUnsigned(true);
1456 // Make sure that our non-designated initializer list has space
1457 // for a subobject corresponding to this array element.
1458 if (DesignatedEndIndex
.getZExtValue() >= StructuredList
->getNumInits())
1459 StructuredList
->resizeInits(SemaRef
.Context
,
1460 DesignatedEndIndex
.getZExtValue() + 1);
1462 // Repeatedly perform subobject initializations in the range
1463 // [DesignatedStartIndex, DesignatedEndIndex].
1465 // Move to the next designator
1466 unsigned ElementIndex
= DesignatedStartIndex
.getZExtValue();
1467 unsigned OldIndex
= Index
;
1468 while (DesignatedStartIndex
<= DesignatedEndIndex
) {
1469 // Recurse to check later designated subobjects.
1470 QualType ElementType
= AT
->getElementType();
1472 if (CheckDesignatedInitializer(IList
, DIE
, DesigIdx
+ 1, ElementType
, 0, 0,
1473 Index
, StructuredList
, ElementIndex
,
1474 (DesignatedStartIndex
== DesignatedEndIndex
),
1478 // Move to the next index in the array that we'll be initializing.
1479 ++DesignatedStartIndex
;
1480 ElementIndex
= DesignatedStartIndex
.getZExtValue();
1483 // If this the first designator, our caller will continue checking
1484 // the rest of this array subobject.
1485 if (IsFirstDesignator
) {
1486 if (NextElementIndex
)
1487 *NextElementIndex
= DesignatedStartIndex
;
1488 StructuredIndex
= ElementIndex
;
1492 if (!FinishSubobjectInit
)
1495 // Check the remaining elements within this array subobject.
1496 bool prevHadError
= hadError
;
1497 CheckArrayType(IList
, CurrentObjectType
, DesignatedStartIndex
, false, Index
,
1498 StructuredList
, ElementIndex
);
1499 return hadError
&& !prevHadError
;
1502 // Get the structured initializer list for a subobject of type
1503 // @p CurrentObjectType.
1505 InitListChecker::getStructuredSubobjectInit(InitListExpr
*IList
, unsigned Index
,
1506 QualType CurrentObjectType
,
1507 InitListExpr
*StructuredList
,
1508 unsigned StructuredIndex
,
1509 SourceRange InitRange
) {
1510 Expr
*ExistingInit
= 0;
1511 if (!StructuredList
)
1512 ExistingInit
= SyntacticToSemantic
[IList
];
1513 else if (StructuredIndex
< StructuredList
->getNumInits())
1514 ExistingInit
= StructuredList
->getInit(StructuredIndex
);
1516 if (InitListExpr
*Result
= dyn_cast_or_null
<InitListExpr
>(ExistingInit
))
1520 // We are creating an initializer list that initializes the
1521 // subobjects of the current object, but there was already an
1522 // initialization that completely initialized the current
1523 // subobject, e.g., by a compound literal:
1525 // struct X { int a, b; };
1526 // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
1528 // Here, xs[0].a == 0 and xs[0].b == 3, since the second,
1529 // designated initializer re-initializes the whole
1530 // subobject [0], overwriting previous initializers.
1531 SemaRef
.Diag(InitRange
.getBegin(),
1532 diag::warn_subobject_initializer_overrides
)
1534 SemaRef
.Diag(ExistingInit
->getSourceRange().getBegin(),
1535 diag::note_previous_initializer
)
1536 << /*FIXME:has side effects=*/0
1537 << ExistingInit
->getSourceRange();
1540 InitListExpr
*Result
1541 = new (SemaRef
.Context
) InitListExpr(InitRange
.getBegin(), 0, 0,
1542 InitRange
.getEnd());
1544 Result
->setType(CurrentObjectType
);
1546 // Pre-allocate storage for the structured initializer list.
1547 unsigned NumElements
= 0;
1548 unsigned NumInits
= 0;
1549 if (!StructuredList
)
1550 NumInits
= IList
->getNumInits();
1551 else if (Index
< IList
->getNumInits()) {
1552 if (InitListExpr
*SubList
= dyn_cast
<InitListExpr
>(IList
->getInit(Index
)))
1553 NumInits
= SubList
->getNumInits();
1556 if (const ArrayType
*AType
1557 = SemaRef
.Context
.getAsArrayType(CurrentObjectType
)) {
1558 if (const ConstantArrayType
*CAType
= dyn_cast
<ConstantArrayType
>(AType
)) {
1559 NumElements
= CAType
->getSize().getZExtValue();
1560 // Simple heuristic so that we don't allocate a very large
1561 // initializer with many empty entries at the end.
1562 if (NumInits
&& NumElements
> NumInits
)
1565 } else if (const VectorType
*VType
= CurrentObjectType
->getAsVectorType())
1566 NumElements
= VType
->getNumElements();
1567 else if (const RecordType
*RType
= CurrentObjectType
->getAsRecordType()) {
1568 RecordDecl
*RDecl
= RType
->getDecl();
1569 if (RDecl
->isUnion())
1572 NumElements
= std::distance(RDecl
->field_begin(),
1573 RDecl
->field_end());
1576 if (NumElements
< NumInits
)
1577 NumElements
= IList
->getNumInits();
1579 Result
->reserveInits(NumElements
);
1581 // Link this new initializer list into the structured initializer
1584 StructuredList
->updateInit(StructuredIndex
, Result
);
1586 Result
->setSyntacticForm(IList
);
1587 SyntacticToSemantic
[IList
] = Result
;
1593 /// Update the initializer at index @p StructuredIndex within the
1594 /// structured initializer list to the value @p expr.
1595 void InitListChecker::UpdateStructuredListElement(InitListExpr
*StructuredList
,
1596 unsigned &StructuredIndex
,
1598 // No structured initializer list to update
1599 if (!StructuredList
)
1602 if (Expr
*PrevInit
= StructuredList
->updateInit(StructuredIndex
, expr
)) {
1603 // This initializer overwrites a previous initializer. Warn.
1604 SemaRef
.Diag(expr
->getSourceRange().getBegin(),
1605 diag::warn_initializer_overrides
)
1606 << expr
->getSourceRange();
1607 SemaRef
.Diag(PrevInit
->getSourceRange().getBegin(),
1608 diag::note_previous_initializer
)
1609 << /*FIXME:has side effects=*/0
1610 << PrevInit
->getSourceRange();
1616 /// Check that the given Index expression is a valid array designator
1617 /// value. This is essentailly just a wrapper around
1618 /// VerifyIntegerConstantExpression that also checks for negative values
1619 /// and produces a reasonable diagnostic if there is a
1620 /// failure. Returns true if there was an error, false otherwise. If
1621 /// everything went okay, Value will receive the value of the constant
1624 CheckArrayDesignatorExpr(Sema
&S
, Expr
*Index
, llvm::APSInt
&Value
) {
1625 SourceLocation Loc
= Index
->getSourceRange().getBegin();
1627 // Make sure this is an integer constant expression.
1628 if (S
.VerifyIntegerConstantExpression(Index
, &Value
))
1631 if (Value
.isSigned() && Value
.isNegative())
1632 return S
.Diag(Loc
, diag::err_array_designator_negative
)
1633 << Value
.toString(10) << Index
->getSourceRange();
1635 Value
.setIsUnsigned(true);
1639 Sema::OwningExprResult
Sema::ActOnDesignatedInitializer(Designation
&Desig
,
1642 OwningExprResult Init
) {
1643 typedef DesignatedInitExpr::Designator ASTDesignator
;
1645 bool Invalid
= false;
1646 llvm::SmallVector
<ASTDesignator
, 32> Designators
;
1647 llvm::SmallVector
<Expr
*, 32> InitExpressions
;
1649 // Build designators and check array designator expressions.
1650 for (unsigned Idx
= 0; Idx
< Desig
.getNumDesignators(); ++Idx
) {
1651 const Designator
&D
= Desig
.getDesignator(Idx
);
1652 switch (D
.getKind()) {
1653 case Designator::FieldDesignator
:
1654 Designators
.push_back(ASTDesignator(D
.getField(), D
.getDotLoc(),
1658 case Designator::ArrayDesignator
: {
1659 Expr
*Index
= static_cast<Expr
*>(D
.getArrayIndex());
1660 llvm::APSInt IndexValue
;
1661 if (!Index
->isTypeDependent() &&
1662 !Index
->isValueDependent() &&
1663 CheckArrayDesignatorExpr(*this, Index
, IndexValue
))
1666 Designators
.push_back(ASTDesignator(InitExpressions
.size(),
1668 D
.getRBracketLoc()));
1669 InitExpressions
.push_back(Index
);
1674 case Designator::ArrayRangeDesignator
: {
1675 Expr
*StartIndex
= static_cast<Expr
*>(D
.getArrayRangeStart());
1676 Expr
*EndIndex
= static_cast<Expr
*>(D
.getArrayRangeEnd());
1677 llvm::APSInt StartValue
;
1678 llvm::APSInt EndValue
;
1679 bool StartDependent
= StartIndex
->isTypeDependent() ||
1680 StartIndex
->isValueDependent();
1681 bool EndDependent
= EndIndex
->isTypeDependent() ||
1682 EndIndex
->isValueDependent();
1683 if ((!StartDependent
&&
1684 CheckArrayDesignatorExpr(*this, StartIndex
, StartValue
)) ||
1686 CheckArrayDesignatorExpr(*this, EndIndex
, EndValue
)))
1689 // Make sure we're comparing values with the same bit width.
1690 if (StartDependent
|| EndDependent
) {
1691 // Nothing to compute.
1692 } else if (StartValue
.getBitWidth() > EndValue
.getBitWidth())
1693 EndValue
.extend(StartValue
.getBitWidth());
1694 else if (StartValue
.getBitWidth() < EndValue
.getBitWidth())
1695 StartValue
.extend(EndValue
.getBitWidth());
1697 if (!StartDependent
&& !EndDependent
&& EndValue
< StartValue
) {
1698 Diag(D
.getEllipsisLoc(), diag::err_array_designator_empty_range
)
1699 << StartValue
.toString(10) << EndValue
.toString(10)
1700 << StartIndex
->getSourceRange() << EndIndex
->getSourceRange();
1703 Designators
.push_back(ASTDesignator(InitExpressions
.size(),
1706 D
.getRBracketLoc()));
1707 InitExpressions
.push_back(StartIndex
);
1708 InitExpressions
.push_back(EndIndex
);
1716 if (Invalid
|| Init
.isInvalid())
1719 // Clear out the expressions within the designation.
1720 Desig
.ClearExprs(*this);
1722 DesignatedInitExpr
*DIE
1723 = DesignatedInitExpr::Create(Context
,
1724 Designators
.data(), Designators
.size(),
1725 InitExpressions
.data(), InitExpressions
.size(),
1726 Loc
, GNUSyntax
, Init
.takeAs
<Expr
>());
1730 bool Sema::CheckInitList(InitListExpr
*&InitList
, QualType
&DeclType
) {
1731 InitListChecker
CheckInitList(*this, InitList
, DeclType
);
1732 if (!CheckInitList
.HadError())
1733 InitList
= CheckInitList
.getFullyStructuredList();
1735 return CheckInitList
.HadError();
1738 /// \brief Diagnose any semantic errors with value-initialization of
1741 /// Value-initialization effectively zero-initializes any types
1742 /// without user-declared constructors, and calls the default
1743 /// constructor for a for any type that has a user-declared
1744 /// constructor (C++ [dcl.init]p5). Value-initialization can fail when
1745 /// a type with a user-declared constructor does not have an
1746 /// accessible, non-deleted default constructor. In C, everything can
1747 /// be value-initialized, which corresponds to C's notion of
1748 /// initializing objects with static storage duration when no
1749 /// initializer is provided for that object.
1751 /// \returns true if there was an error, false otherwise.
1752 bool Sema::CheckValueInitialization(QualType Type
, SourceLocation Loc
) {
1753 // C++ [dcl.init]p5:
1755 // To value-initialize an object of type T means:
1757 // -- if T is an array type, then each element is value-initialized;
1758 if (const ArrayType
*AT
= Context
.getAsArrayType(Type
))
1759 return CheckValueInitialization(AT
->getElementType(), Loc
);
1761 if (const RecordType
*RT
= Type
->getAsRecordType()) {
1762 if (CXXRecordDecl
*ClassDecl
= dyn_cast
<CXXRecordDecl
>(RT
->getDecl())) {
1763 // -- if T is a class type (clause 9) with a user-declared
1764 // constructor (12.1), then the default constructor for T is
1765 // called (and the initialization is ill-formed if T has no
1766 // accessible default constructor);
1767 if (ClassDecl
->hasUserDeclaredConstructor())
1768 // FIXME: Eventually, we'll need to put the constructor decl into the
1770 return PerformInitializationByConstructor(Type
, 0, 0, Loc
,
1777 if (Type
->isReferenceType()) {
1778 // C++ [dcl.init]p5:
1779 // [...] A program that calls for default-initialization or
1780 // value-initialization of an entity of reference type is
1781 // ill-formed. [...]
1782 // FIXME: Once we have code that goes through this path, add an actual