SemaInit.cpp revision ab6e38adbcdbdb4e7d211b4ff7a52d871ea0e994 
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(),
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(),
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(),
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();
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();
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();
1094  FieldIndex = 0;
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(),
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 = 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
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}
1783