SemaInit.cpp revision 88e09ccef0d019211f738178fc7b8390a6327577 
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.getConstantArrayWithoutExprType(IAT->getElementType(),
101                                                      ConstVal,
102                                                      ArrayType::Normal, 0);
103    return;
104  }
105
106  const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
107
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();
115
116  // Set the type to the actual size that we are initializing.  If we have
117  // something like:
118  //   char x[1] = "foo";
119  // then this will set the string literal's type to char[1].
120  Str->setType(DeclT);
121}
122
123bool Sema::CheckInitializerTypes(Expr *&Init, QualType &DeclType,
124                                 SourceLocation InitLoc,
125                                 DeclarationName InitEntity, bool DirectInit) {
126  if (DeclType->isDependentType() ||
127      Init->isTypeDependent() || Init->isValueDependent())
128    return false;
129
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);
136
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();
142
143  InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
144  if (!InitList) {
145    // FIXME: Handle wide strings
146    if (Expr *Str = IsStringInit(Init, DeclType, Context)) {
147      CheckStringInit(Str, DeclType, *this);
148      return false;
149    }
150
151    // C++ [dcl.init]p14:
152    //   -- If the destination type is a (possibly cv-qualified) class
153    //      type:
154    if (getLangOptions().CPlusPlus && DeclType->isRecordType()) {
155      QualType DeclTypeC = Context.getCanonicalType(DeclType);
156      QualType InitTypeC = Context.getCanonicalType(Init->getType());
157
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->getAs<RecordType>()->getDecl());
166
167        // No need to make a CXXConstructExpr if both the ctor and dtor are
168        // trivial.
169        if (RD->hasTrivialConstructor() && RD->hasTrivialDestructor())
170          return false;
171
172        CXXConstructorDecl *Constructor
173        = PerformInitializationByConstructor(DeclType, &Init, 1,
174                                             InitLoc, Init->getSourceRange(),
175                                             InitEntity,
176                                             DirectInit? IK_Direct : IK_Copy);
177        if (!Constructor)
178          return true;
179
180        Init = BuildCXXConstructExpr(Context,
181                                     DeclType, Constructor, false, &Init, 1);
182        Init = MaybeCreateCXXExprWithTemporaries(Init, /*DestroyTemps=*/true);
183        return false;
184      }
185
186      //   -- Otherwise (i.e., for the remaining copy-initialization
187      //      cases), user-defined conversion sequences that can
188      //      convert from the source type to the destination type or
189      //      (when a conversion function is used) to a derived class
190      //      thereof are enumerated as described in 13.3.1.4, and the
191      //      best one is chosen through overload resolution
192      //      (13.3). If the conversion cannot be done or is
193      //      ambiguous, the initialization is ill-formed. The
194      //      function selected is called with the initializer
195      //      expression as its argument; if the function is a
196      //      constructor, the call initializes a temporary of the
197      //      destination type.
198      // FIXME: We're pretending to do copy elision here; return to this when we
199      // have ASTs for such things.
200      if (!PerformImplicitConversion(Init, DeclType, "initializing"))
201        return false;
202
203      if (InitEntity)
204        return Diag(InitLoc, diag::err_cannot_initialize_decl)
205          << InitEntity << (int)(Init->isLvalue(Context) == Expr::LV_Valid)
206          << Init->getType() << Init->getSourceRange();
207      return Diag(InitLoc, diag::err_cannot_initialize_decl_noname)
208        << DeclType << (int)(Init->isLvalue(Context) == Expr::LV_Valid)
209        << Init->getType() << Init->getSourceRange();
210    }
211
212    // C99 6.7.8p16.
213    if (DeclType->isArrayType())
214      return Diag(Init->getLocStart(), diag::err_array_init_list_required)
215        << Init->getSourceRange();
216
217    return CheckSingleInitializer(Init, DeclType, DirectInit, *this);
218  }
219
220  bool hadError = CheckInitList(InitList, DeclType);
221  Init = InitList;
222  return hadError;
223}
224
225//===----------------------------------------------------------------------===//
226// Semantic checking for initializer lists.
227//===----------------------------------------------------------------------===//
228
229/// @brief Semantic checking for initializer lists.
230///
231/// The InitListChecker class contains a set of routines that each
232/// handle the initialization of a certain kind of entity, e.g.,
233/// arrays, vectors, struct/union types, scalars, etc. The
234/// InitListChecker itself performs a recursive walk of the subobject
235/// structure of the type to be initialized, while stepping through
236/// the initializer list one element at a time. The IList and Index
237/// parameters to each of the Check* routines contain the active
238/// (syntactic) initializer list and the index into that initializer
239/// list that represents the current initializer. Each routine is
240/// responsible for moving that Index forward as it consumes elements.
241///
242/// Each Check* routine also has a StructuredList/StructuredIndex
243/// arguments, which contains the current the "structured" (semantic)
244/// initializer list and the index into that initializer list where we
245/// are copying initializers as we map them over to the semantic
246/// list. Once we have completed our recursive walk of the subobject
247/// structure, we will have constructed a full semantic initializer
248/// list.
249///
250/// C99 designators cause changes in the initializer list traversal,
251/// because they make the initialization "jump" into a specific
252/// subobject and then continue the initialization from that
253/// point. CheckDesignatedInitializer() recursively steps into the
254/// designated subobject and manages backing out the recursion to
255/// initialize the subobjects after the one designated.
256namespace {
257class InitListChecker {
258  Sema &SemaRef;
259  bool hadError;
260  std::map<InitListExpr *, InitListExpr *> SyntacticToSemantic;
261  InitListExpr *FullyStructuredList;
262
263  void CheckImplicitInitList(InitListExpr *ParentIList, QualType T,
264                             unsigned &Index, InitListExpr *StructuredList,
265                             unsigned &StructuredIndex,
266                             bool TopLevelObject = false);
267  void CheckExplicitInitList(InitListExpr *IList, QualType &T,
268                             unsigned &Index, InitListExpr *StructuredList,
269                             unsigned &StructuredIndex,
270                             bool TopLevelObject = false);
271  void CheckListElementTypes(InitListExpr *IList, QualType &DeclType,
272                             bool SubobjectIsDesignatorContext,
273                             unsigned &Index,
274                             InitListExpr *StructuredList,
275                             unsigned &StructuredIndex,
276                             bool TopLevelObject = false);
277  void CheckSubElementType(InitListExpr *IList, QualType ElemType,
278                           unsigned &Index,
279                           InitListExpr *StructuredList,
280                           unsigned &StructuredIndex);
281  void CheckScalarType(InitListExpr *IList, QualType DeclType,
282                       unsigned &Index,
283                       InitListExpr *StructuredList,
284                       unsigned &StructuredIndex);
285  void CheckReferenceType(InitListExpr *IList, QualType DeclType,
286                          unsigned &Index,
287                          InitListExpr *StructuredList,
288                          unsigned &StructuredIndex);
289  void CheckVectorType(InitListExpr *IList, QualType DeclType, unsigned &Index,
290                       InitListExpr *StructuredList,
291                       unsigned &StructuredIndex);
292  void CheckStructUnionTypes(InitListExpr *IList, QualType DeclType,
293                             RecordDecl::field_iterator Field,
294                             bool SubobjectIsDesignatorContext, unsigned &Index,
295                             InitListExpr *StructuredList,
296                             unsigned &StructuredIndex,
297                             bool TopLevelObject = false);
298  void CheckArrayType(InitListExpr *IList, QualType &DeclType,
299                      llvm::APSInt elementIndex,
300                      bool SubobjectIsDesignatorContext, unsigned &Index,
301                      InitListExpr *StructuredList,
302                      unsigned &StructuredIndex);
303  bool CheckDesignatedInitializer(InitListExpr *IList, DesignatedInitExpr *DIE,
304                                  unsigned DesigIdx,
305                                  QualType &CurrentObjectType,
306                                  RecordDecl::field_iterator *NextField,
307                                  llvm::APSInt *NextElementIndex,
308                                  unsigned &Index,
309                                  InitListExpr *StructuredList,
310                                  unsigned &StructuredIndex,
311                                  bool FinishSubobjectInit,
312                                  bool TopLevelObject);
313  InitListExpr *getStructuredSubobjectInit(InitListExpr *IList, unsigned Index,
314                                           QualType CurrentObjectType,
315                                           InitListExpr *StructuredList,
316                                           unsigned StructuredIndex,
317                                           SourceRange InitRange);
318  void UpdateStructuredListElement(InitListExpr *StructuredList,
319                                   unsigned &StructuredIndex,
320                                   Expr *expr);
321  int numArrayElements(QualType DeclType);
322  int numStructUnionElements(QualType DeclType);
323
324  void FillInValueInitializations(InitListExpr *ILE);
325public:
326  InitListChecker(Sema &S, InitListExpr *IL, QualType &T);
327  bool HadError() { return hadError; }
328
329  // @brief Retrieves the fully-structured initializer list used for
330  // semantic analysis and code generation.
331  InitListExpr *getFullyStructuredList() const { return FullyStructuredList; }
332};
333} // end anonymous namespace
334
335/// Recursively replaces NULL values within the given initializer list
336/// with expressions that perform value-initialization of the
337/// appropriate type.
338void InitListChecker::FillInValueInitializations(InitListExpr *ILE) {
339  assert((ILE->getType() != SemaRef.Context.VoidTy) &&
340         "Should not have void type");
341  SourceLocation Loc = ILE->getSourceRange().getBegin();
342  if (ILE->getSyntacticForm())
343    Loc = ILE->getSyntacticForm()->getSourceRange().getBegin();
344
345  if (const RecordType *RType = ILE->getType()->getAs<RecordType>()) {
346    unsigned Init = 0, NumInits = ILE->getNumInits();
347    for (RecordDecl::field_iterator
348           Field = RType->getDecl()->field_begin(),
349           FieldEnd = RType->getDecl()->field_end();
350         Field != FieldEnd; ++Field) {
351      if (Field->isUnnamedBitfield())
352        continue;
353
354      if (Init >= NumInits || !ILE->getInit(Init)) {
355        if (Field->getType()->isReferenceType()) {
356          // C++ [dcl.init.aggr]p9:
357          //   If an incomplete or empty initializer-list leaves a
358          //   member of reference type uninitialized, the program is
359          //   ill-formed.
360          SemaRef.Diag(Loc, diag::err_init_reference_member_uninitialized)
361            << Field->getType()
362            << ILE->getSyntacticForm()->getSourceRange();
363          SemaRef.Diag(Field->getLocation(),
364                        diag::note_uninit_reference_member);
365          hadError = true;
366          return;
367        } else if (SemaRef.CheckValueInitialization(Field->getType(), Loc)) {
368          hadError = true;
369          return;
370        }
371
372        // FIXME: If value-initialization involves calling a constructor, should
373        // we make that call explicit in the representation (even when it means
374        // extending the initializer list)?
375        if (Init < NumInits && !hadError)
376          ILE->setInit(Init,
377              new (SemaRef.Context) ImplicitValueInitExpr(Field->getType()));
378      } else if (InitListExpr *InnerILE
379                 = dyn_cast<InitListExpr>(ILE->getInit(Init)))
380        FillInValueInitializations(InnerILE);
381      ++Init;
382
383      // Only look at the first initialization of a union.
384      if (RType->getDecl()->isUnion())
385        break;
386    }
387
388    return;
389  }
390
391  QualType ElementType;
392
393  unsigned NumInits = ILE->getNumInits();
394  unsigned NumElements = NumInits;
395  if (const ArrayType *AType = SemaRef.Context.getAsArrayType(ILE->getType())) {
396    ElementType = AType->getElementType();
397    if (const ConstantArrayType *CAType = dyn_cast<ConstantArrayType>(AType))
398      NumElements = CAType->getSize().getZExtValue();
399  } else if (const VectorType *VType = ILE->getType()->getAsVectorType()) {
400    ElementType = VType->getElementType();
401    NumElements = VType->getNumElements();
402  } else
403    ElementType = ILE->getType();
404
405  for (unsigned Init = 0; Init != NumElements; ++Init) {
406    if (Init >= NumInits || !ILE->getInit(Init)) {
407      if (SemaRef.CheckValueInitialization(ElementType, Loc)) {
408        hadError = true;
409        return;
410      }
411
412      // FIXME: If value-initialization involves calling a constructor, should
413      // we make that call explicit in the representation (even when it means
414      // extending the initializer list)?
415      if (Init < NumInits && !hadError)
416        ILE->setInit(Init,
417                     new (SemaRef.Context) ImplicitValueInitExpr(ElementType));
418    } else if (InitListExpr *InnerILE
419               = dyn_cast<InitListExpr>(ILE->getInit(Init)))
420      FillInValueInitializations(InnerILE);
421  }
422}
423
424
425InitListChecker::InitListChecker(Sema &S, InitListExpr *IL, QualType &T)
426  : SemaRef(S) {
427  hadError = false;
428
429  unsigned newIndex = 0;
430  unsigned newStructuredIndex = 0;
431  FullyStructuredList
432    = getStructuredSubobjectInit(IL, newIndex, T, 0, 0, IL->getSourceRange());
433  CheckExplicitInitList(IL, T, newIndex, FullyStructuredList, newStructuredIndex,
434                        /*TopLevelObject=*/true);
435
436  if (!hadError)
437    FillInValueInitializations(FullyStructuredList);
438}
439
440int InitListChecker::numArrayElements(QualType DeclType) {
441  // FIXME: use a proper constant
442  int maxElements = 0x7FFFFFFF;
443  if (const ConstantArrayType *CAT =
444        SemaRef.Context.getAsConstantArrayType(DeclType)) {
445    maxElements = static_cast<int>(CAT->getSize().getZExtValue());
446  }
447  return maxElements;
448}
449
450int InitListChecker::numStructUnionElements(QualType DeclType) {
451  RecordDecl *structDecl = DeclType->getAs<RecordType>()->getDecl();
452  int InitializableMembers = 0;
453  for (RecordDecl::field_iterator
454         Field = structDecl->field_begin(),
455         FieldEnd = structDecl->field_end();
456       Field != FieldEnd; ++Field) {
457    if ((*Field)->getIdentifier() || !(*Field)->isBitField())
458      ++InitializableMembers;
459  }
460  if (structDecl->isUnion())
461    return std::min(InitializableMembers, 1);
462  return InitializableMembers - structDecl->hasFlexibleArrayMember();
463}
464
465void InitListChecker::CheckImplicitInitList(InitListExpr *ParentIList,
466                                            QualType T, unsigned &Index,
467                                            InitListExpr *StructuredList,
468                                            unsigned &StructuredIndex,
469                                            bool TopLevelObject) {
470  int maxElements = 0;
471
472  if (T->isArrayType())
473    maxElements = numArrayElements(T);
474  else if (T->isStructureType() || T->isUnionType())
475    maxElements = numStructUnionElements(T);
476  else if (T->isVectorType())
477    maxElements = T->getAsVectorType()->getNumElements();
478  else
479    assert(0 && "CheckImplicitInitList(): Illegal type");
480
481  if (maxElements == 0) {
482    SemaRef.Diag(ParentIList->getInit(Index)->getLocStart(),
483                  diag::err_implicit_empty_initializer);
484    ++Index;
485    hadError = true;
486    return;
487  }
488
489  // Build a structured initializer list corresponding to this subobject.
490  InitListExpr *StructuredSubobjectInitList
491    = getStructuredSubobjectInit(ParentIList, Index, T, StructuredList,
492                                 StructuredIndex,
493          SourceRange(ParentIList->getInit(Index)->getSourceRange().getBegin(),
494                      ParentIList->getSourceRange().getEnd()));
495  unsigned StructuredSubobjectInitIndex = 0;
496
497  // Check the element types and build the structural subobject.
498  unsigned StartIndex = Index;
499  CheckListElementTypes(ParentIList, T, false, Index,
500                        StructuredSubobjectInitList,
501                        StructuredSubobjectInitIndex,
502                        TopLevelObject);
503  unsigned EndIndex = (Index == StartIndex? StartIndex : Index - 1);
504  StructuredSubobjectInitList->setType(T);
505
506  // Update the structured sub-object initializer so that it's ending
507  // range corresponds with the end of the last initializer it used.
508  if (EndIndex < ParentIList->getNumInits()) {
509    SourceLocation EndLoc
510      = ParentIList->getInit(EndIndex)->getSourceRange().getEnd();
511    StructuredSubobjectInitList->setRBraceLoc(EndLoc);
512  }
513}
514
515void InitListChecker::CheckExplicitInitList(InitListExpr *IList, QualType &T,
516                                            unsigned &Index,
517                                            InitListExpr *StructuredList,
518                                            unsigned &StructuredIndex,
519                                            bool TopLevelObject) {
520  assert(IList->isExplicit() && "Illegal Implicit InitListExpr");
521  SyntacticToSemantic[IList] = StructuredList;
522  StructuredList->setSyntacticForm(IList);
523  CheckListElementTypes(IList, T, true, Index, StructuredList,
524                        StructuredIndex, TopLevelObject);
525  IList->setType(T);
526  StructuredList->setType(T);
527  if (hadError)
528    return;
529
530  if (Index < IList->getNumInits()) {
531    // We have leftover initializers
532    if (StructuredIndex == 1 &&
533        IsStringInit(StructuredList->getInit(0), T, SemaRef.Context)) {
534      unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
535      if (SemaRef.getLangOptions().CPlusPlus) {
536        DK = diag::err_excess_initializers_in_char_array_initializer;
537        hadError = true;
538      }
539      // Special-case
540      SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
541        << IList->getInit(Index)->getSourceRange();
542    } else if (!T->isIncompleteType()) {
543      // Don't complain for incomplete types, since we'll get an error
544      // elsewhere
545      QualType CurrentObjectType = StructuredList->getType();
546      int initKind =
547        CurrentObjectType->isArrayType()? 0 :
548        CurrentObjectType->isVectorType()? 1 :
549        CurrentObjectType->isScalarType()? 2 :
550        CurrentObjectType->isUnionType()? 3 :
551        4;
552
553      unsigned DK = diag::warn_excess_initializers;
554      if (SemaRef.getLangOptions().CPlusPlus) {
555        DK = diag::err_excess_initializers;
556        hadError = true;
557      }
558      if (SemaRef.getLangOptions().OpenCL && initKind == 1) {
559        DK = diag::err_excess_initializers;
560        hadError = true;
561      }
562
563      SemaRef.Diag(IList->getInit(Index)->getLocStart(), DK)
564        << initKind << IList->getInit(Index)->getSourceRange();
565    }
566  }
567
568  if (T->isScalarType() && !TopLevelObject)
569    SemaRef.Diag(IList->getLocStart(), diag::warn_braces_around_scalar_init)
570      << IList->getSourceRange()
571      << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocStart()))
572      << CodeModificationHint::CreateRemoval(SourceRange(IList->getLocEnd()));
573}
574
575void InitListChecker::CheckListElementTypes(InitListExpr *IList,
576                                            QualType &DeclType,
577                                            bool SubobjectIsDesignatorContext,
578                                            unsigned &Index,
579                                            InitListExpr *StructuredList,
580                                            unsigned &StructuredIndex,
581                                            bool TopLevelObject) {
582  if (DeclType->isScalarType()) {
583    CheckScalarType(IList, DeclType, Index, StructuredList, StructuredIndex);
584  } else if (DeclType->isVectorType()) {
585    CheckVectorType(IList, DeclType, Index, StructuredList, StructuredIndex);
586  } else if (DeclType->isAggregateType()) {
587    if (DeclType->isRecordType()) {
588      RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
589      CheckStructUnionTypes(IList, DeclType, RD->field_begin(),
590                            SubobjectIsDesignatorContext, Index,
591                            StructuredList, StructuredIndex,
592                            TopLevelObject);
593    } else if (DeclType->isArrayType()) {
594      llvm::APSInt Zero(
595                      SemaRef.Context.getTypeSize(SemaRef.Context.getSizeType()),
596                      false);
597      CheckArrayType(IList, DeclType, Zero, SubobjectIsDesignatorContext, Index,
598                     StructuredList, StructuredIndex);
599    } else
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.
603    ++Index;
604    SemaRef.Diag(IList->getLocStart(), diag::err_illegal_initializer_type)
605      << DeclType;
606    hadError = true;
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.
611    //
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
614    // an aggregate.
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();
618    hadError = true;
619  } else if (DeclType->isReferenceType()) {
620    CheckReferenceType(IList, DeclType, Index, StructuredList, StructuredIndex);
621  } else {
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");
625  }
626}
627
628void InitListChecker::CheckSubElementType(InitListExpr *IList,
629                                          QualType ElemType,
630                                          unsigned &Index,
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);
643    ++StructuredIndex;
644    ++Index;
645  } else if (Expr *Str = IsStringInit(expr, ElemType, SemaRef.Context)) {
646    CheckStringInit(Str, ElemType, SemaRef);
647    UpdateStructuredListElement(StructuredList, StructuredIndex, Str);
648    ++Index;
649  } else if (ElemType->isScalarType()) {
650    CheckScalarType(IList, ElemType, Index, StructuredList, StructuredIndex);
651  } else if (ElemType->isReferenceType()) {
652    CheckReferenceType(IList, ElemType, Index, StructuredList, StructuredIndex);
653  } else {
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,
664                                               "initializing"))
665          hadError = true;
666        UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
667        ++Index;
668        return;
669      }
670
671      // Fall through for subaggregate initialization
672    } else {
673      // C99 6.7.8p13:
674      //
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);
684        ++Index;
685        return;
686      }
687
688      // Fall through for subaggregate initialization
689    }
690
691    // C++ [dcl.init.aggr]p12:
692    //
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
696    //   the subaggregate.
697    if (ElemType->isAggregateType() || ElemType->isVectorType()) {
698      CheckImplicitInitList(IList, ElemType, Index, StructuredList,
699                            StructuredIndex);
700      ++StructuredIndex;
701    } else {
702      // We cannot initialize this element, so let
703      // PerformCopyInitialization produce the appropriate diagnostic.
704      SemaRef.PerformCopyInitialization(expr, ElemType, "initializing");
705      hadError = true;
706      ++Index;
707      ++StructuredIndex;
708    }
709  }
710}
711
712void InitListChecker::CheckScalarType(InitListExpr *IList, QualType DeclType,
713                                      unsigned &Index,
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();
722      hadError = true;
723      ++Index;
724      ++StructuredIndex;
725      return;
726    } else if (isa<DesignatedInitExpr>(expr)) {
727      SemaRef.Diag(expr->getSourceRange().getBegin(),
728                    diag::err_designator_for_scalar_init)
729        << DeclType << expr->getSourceRange();
730      hadError = true;
731      ++Index;
732      ++StructuredIndex;
733      return;
734    }
735
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);
742    }
743    if (hadError)
744      ++StructuredIndex;
745    else
746      UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
747    ++Index;
748  } else {
749    SemaRef.Diag(IList->getLocStart(), diag::err_empty_scalar_initializer)
750      << IList->getSourceRange();
751    hadError = true;
752    ++Index;
753    ++StructuredIndex;
754    return;
755  }
756}
757
758void InitListChecker::CheckReferenceType(InitListExpr *IList, QualType DeclType,
759                                         unsigned &Index,
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();
767      hadError = true;
768      ++Index;
769      ++StructuredIndex;
770      return;
771    }
772
773    Expr *savExpr = expr; // Might be promoted by CheckSingleInitializer.
774    if (SemaRef.CheckReferenceInit(expr, DeclType))
775      hadError = true;
776    else if (savExpr != expr) {
777      // The type was promoted, update initializer list.
778      IList->setInit(Index, expr);
779    }
780    if (hadError)
781      ++StructuredIndex;
782    else
783      UpdateStructuredListElement(StructuredList, StructuredIndex, expr);
784    ++Index;
785  } else {
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
789    // initialized.
790    SemaRef.Diag(IList->getLocStart(),
791                  diag::err_init_reference_member_uninitialized)
792      << DeclType
793      << IList->getSourceRange();
794    hadError = true;
795    ++Index;
796    ++StructuredIndex;
797    return;
798  }
799}
800
801void InitListChecker::CheckVectorType(InitListExpr *IList, QualType DeclType,
802                                      unsigned &Index,
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();
809
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())
813        break;
814      CheckSubElementType(IList, elementType, Index,
815                          StructuredList, StructuredIndex);
816    }
817  }
818}
819
820void InitListChecker::CheckArrayType(InitListExpr *IList, QualType &DeclType,
821                                     llvm::APSInt elementIndex,
822                                     bool SubobjectIsDesignatorContext,
823                                     unsigned &Index,
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,
829                                 SemaRef.Context)) {
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);
838      ++Index;
839      return;
840    }
841  }
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();
850    hadError = true;
851    ++Index;
852    ++StructuredIndex;
853    return;
854  }
855
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;
866  }
867
868  QualType elementType = SemaRef.Context.getAsArrayType(DeclType)
869                             ->getElementType();
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)
877        return;
878
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,
884                                     false)) {
885        hadError = true;
886        continue;
887      }
888
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());
894
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;
899
900      continue;
901    }
902
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)
906      break;
907
908    // Check this element.
909    CheckSubElementType(IList, elementType, Index,
910                        StructuredList, StructuredIndex);
911    ++elementIndex;
912
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;
917  }
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);
927    }
928
929    DeclType = SemaRef.Context.getConstantArrayType(elementType, maxElements,
930                                                     ArrayType::Normal, 0);
931  }
932}
933
934void InitListChecker::CheckStructUnionTypes(InitListExpr *IList,
935                                            QualType DeclType,
936                                            RecordDecl::field_iterator Field,
937                                            bool SubobjectIsDesignatorContext,
938                                            unsigned &Index,
939                                            InitListExpr *StructuredList,
940                                            unsigned &StructuredIndex,
941                                            bool TopLevelObject) {
942  RecordDecl* structDecl = DeclType->getAs<RecordType>()->getDecl();
943
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()) {
947    hadError = true;
948    return;
949  }
950
951  if (DeclType->isUnionType() && IList->getNumInits() == 0) {
952    // Value-initialize the first named member of the union.
953    RecordDecl *RD = DeclType->getAs<RecordType>()->getDecl();
954    for (RecordDecl::field_iterator FieldEnd = RD->field_end();
955         Field != FieldEnd; ++Field) {
956      if (Field->getDeclName()) {
957        StructuredList->setInitializedFieldInUnion(*Field);
958        break;
959      }
960    }
961    return;
962  }
963
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->getAs<RecordType>()->getDecl();
969  RecordDecl::field_iterator FieldEnd = RD->field_end();
970  bool InitializedSomething = false;
971  while (Index < IList->getNumInits()) {
972    Expr *Init = IList->getInit(Index);
973
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)
979        return;
980
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))
987        hadError = true;
988
989      InitializedSomething = true;
990      continue;
991    }
992
993    if (Field == FieldEnd) {
994      // We've run out of fields. We're done.
995      break;
996    }
997
998    // We've already initialized a member of a union. We're done.
999    if (InitializedSomething && DeclType->isUnionType())
1000      break;
1001
1002    // If we've hit the flexible array member at the end, we're done.
1003    if (Field->getType()->isIncompleteArrayType())
1004      break;
1005
1006    if (Field->isUnnamedBitfield()) {
1007      // Don't initialize unnamed bitfields, e.g. "int : 20;"
1008      ++Field;
1009      continue;
1010    }
1011
1012    CheckSubElementType(IList, Field->getType(), Index,
1013                        StructuredList, StructuredIndex);
1014    InitializedSomething = true;
1015
1016    if (DeclType->isUnionType()) {
1017      // Initialize the first field within the union.
1018      StructuredList->setInitializedFieldInUnion(*Field);
1019    }
1020
1021    ++Field;
1022  }
1023
1024  if (Field == FieldEnd || !Field->getType()->isIncompleteArrayType() ||
1025      Index >= IList->getNumInits())
1026    return;
1027
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)
1036      << *Field;
1037    hadError = true;
1038    ++Index;
1039    return;
1040  } else {
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)
1045      << *Field;
1046  }
1047
1048  if (isa<InitListExpr>(IList->getInit(Index)))
1049    CheckSubElementType(IList, Field->getType(), Index, StructuredList,
1050                        StructuredIndex);
1051  else
1052    CheckImplicitInitList(IList, Field->getType(), Index, StructuredList,
1053                          StructuredIndex);
1054}
1055
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.
1059///
1060/// Field/FieldIndex will be updated to point to the (new)
1061/// currently-designated field.
1062static void ExpandAnonymousFieldDesignator(Sema &SemaRef,
1063                                           DesignatedInitExpr *DIE,
1064                                           unsigned DesigIdx,
1065                                           FieldDecl *Field,
1066                                        RecordDecl::field_iterator &FieldIter,
1067                                           unsigned &FieldIndex) {
1068  typedef DesignatedInitExpr::Designator Designator;
1069
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);
1074
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()));
1084    else
1085      Replacements.push_back(Designator((IdentifierInfo *)0, SourceLocation(),
1086                                        SourceLocation()));
1087    Replacements.back().setField(*FI);
1088  }
1089
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());
1095
1096  // Update FieldIter/FieldIndex;
1097  RecordDecl *Record = cast<RecordDecl>(Path.back()->getDeclContext());
1098  FieldIter = Record->field_begin();
1099  FieldIndex = 0;
1100  for (RecordDecl::field_iterator FEnd = Record->field_end();
1101       FieldIter != FEnd; ++FieldIter) {
1102    if (FieldIter->isUnnamedBitfield())
1103        continue;
1104
1105    if (*FieldIter == Path.back())
1106      return;
1107
1108    ++FieldIndex;
1109  }
1110
1111  assert(false && "Unable to find anonymous struct/union field");
1112}
1113
1114/// @brief Check the well-formedness of a C99 designated initializer.
1115///
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).
1122///
1123/// @param IList  The initializer list in which this designated
1124/// initializer occurs.
1125///
1126/// @param DIE The designated initializer expression.
1127///
1128/// @param DesigIdx  The index of the current designator.
1129///
1130/// @param DeclType  The type of the "current object" (C99 6.7.8p17),
1131/// into which the designation in @p DIE should refer.
1132///
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.
1136///
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.
1140///
1141/// @param Index  Index into @p IList where the designated initializer
1142/// @p DIE occurs.
1143///
1144/// @param StructuredList  The initializer list expression that
1145/// describes all of the subobject initializers in the order they'll
1146/// actually be initialized.
1147///
1148/// @returns true if there was an error, false otherwise.
1149bool
1150InitListChecker::CheckDesignatedInitializer(InitListExpr *IList,
1151                                      DesignatedInitExpr *DIE,
1152                                      unsigned DesigIdx,
1153                                      QualType &CurrentObjectType,
1154                                      RecordDecl::field_iterator *NextField,
1155                                      llvm::APSInt *NextElementIndex,
1156                                      unsigned &Index,
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;
1164
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());
1170
1171    CheckSubElementType(IList, CurrentObjectType, Index,
1172                        StructuredList, StructuredIndex);
1173
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);
1179
1180    return hadError && !prevHadError;
1181  }
1182
1183  bool IsFirstDesignator = (DesigIdx == 0);
1184  assert((IsFirstDesignator || StructuredList) &&
1185         "Need a non-designated initializer list to start from");
1186
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");
1196
1197  if (D->isFieldDesignator()) {
1198    // C99 6.7.8p7:
1199    //
1200    //   If a designator has the form
1201    //
1202    //      . identifier
1203    //
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->getAs<RecordType>();
1208    if (!RT) {
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;
1214      ++Index;
1215      return true;
1216    }
1217
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())
1229        continue;
1230
1231      if (KnownField == *Field || Field->getIdentifier() == FieldName)
1232        break;
1233
1234      ++FieldIndex;
1235    }
1236
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
1242      // struct/union.
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;
1248        ++Index;
1249        return true;
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),
1257                                       Field, FieldIndex);
1258        D = DIE->getDesignator(DesigIdx);
1259      } else {
1260        // Name lookup found something, but it wasn't a field.
1261        SemaRef.Diag(D->getFieldLoc(), diag::err_field_designator_nonfield)
1262          << FieldName;
1263        SemaRef.Diag((*Lookup.first)->getLocation(),
1264                      diag::note_field_designator_found);
1265        ++Index;
1266        return true;
1267      }
1268    } else if (!KnownField &&
1269               cast<RecordDecl>((*Field)->getDeclContext())
1270                 ->isAnonymousStructOrUnion()) {
1271      ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, *Field,
1272                                     Field, FieldIndex);
1273      D = DIE->getDesignator(DesigIdx);
1274    }
1275
1276    // All of the fields of a union are located at the same place in
1277    // the initializer list.
1278    if (RT->getDecl()->isUnion()) {
1279      FieldIndex = 0;
1280      StructuredList->setInitializedFieldInUnion(*Field);
1281    }
1282
1283    // Update the designator with the field declaration.
1284    D->setField(*Field);
1285
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);
1290
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)
1304          << *Field;
1305        Invalid = true;
1306      }
1307
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)
1314          << *Field;
1315        Invalid = true;
1316      }
1317
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)
1325          << *Field;
1326        Invalid = true;
1327      }
1328
1329      if (Invalid) {
1330        ++Index;
1331        return true;
1332      }
1333
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) {
1343        ++Field;
1344        ++FieldIndex;
1345        if (NextField)
1346          *NextField = Field;
1347        StructuredIndex = FieldIndex;
1348        return true;
1349      }
1350    } else {
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,
1356                                     true, false))
1357        return true;
1358    }
1359
1360    // Find the position of the next field to be initialized in this
1361    // subobject.
1362    ++Field;
1363    ++FieldIndex;
1364
1365    // If this the first designator, our caller will continue checking
1366    // the rest of this struct/class/union subobject.
1367    if (IsFirstDesignator) {
1368      if (NextField)
1369        *NextField = Field;
1370      StructuredIndex = FieldIndex;
1371      return false;
1372    }
1373
1374    if (!FinishSubobjectInit)
1375      return false;
1376
1377    // We've already initialized something in the union; we're done.
1378    if (RT->getDecl()->isUnion())
1379      return hadError;
1380
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;
1386  }
1387
1388  // C99 6.7.8p6:
1389  //
1390  //   If a designator has the form
1391  //
1392  //      [ constant-expression ]
1393  //
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.
1398  //
1399  // Additionally, cope with the GNU extension that permits
1400  // designators of the form
1401  //
1402  //      [ constant-expression ... constant-expression ]
1403  const ArrayType *AT = SemaRef.Context.getAsArrayType(CurrentObjectType);
1404  if (!AT) {
1405    SemaRef.Diag(D->getLBracketLoc(), diag::err_array_designator_non_array)
1406      << CurrentObjectType;
1407    ++Index;
1408    return true;
1409  }
1410
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;
1417  } else {
1418    assert(D->isArrayRangeDesignator() && "Need array-range designator");
1419
1420
1421    DesignatedStartIndex =
1422      DIE->getArrayRangeStart(*D)->EvaluateAsInt(SemaRef.Context);
1423    DesignatedEndIndex =
1424      DIE->getArrayRangeEnd(*D)->EvaluateAsInt(SemaRef.Context);
1425    IndexExpr = DIE->getArrayRangeEnd(*D);
1426
1427    if (DesignatedStartIndex.getZExtValue() !=DesignatedEndIndex.getZExtValue())
1428      FullyStructuredList->sawArrayRangeDesignator();
1429  }
1430
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();
1442      ++Index;
1443      return true;
1444    }
1445  } else {
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);
1454  }
1455
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);
1461
1462  // Repeatedly perform subobject initializations in the range
1463  // [DesignatedStartIndex, DesignatedEndIndex].
1464
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();
1471    Index = OldIndex;
1472    if (CheckDesignatedInitializer(IList, DIE, DesigIdx + 1, ElementType, 0, 0,
1473                                   Index, StructuredList, ElementIndex,
1474                                   (DesignatedStartIndex == DesignatedEndIndex),
1475                                   false))
1476      return true;
1477
1478    // Move to the next index in the array that we'll be initializing.
1479    ++DesignatedStartIndex;
1480    ElementIndex = DesignatedStartIndex.getZExtValue();
1481  }
1482
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;
1489    return false;
1490  }
1491
1492  if (!FinishSubobjectInit)
1493    return false;
1494
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;
1500}
1501
1502// Get the structured initializer list for a subobject of type
1503// @p CurrentObjectType.
1504InitListExpr *
1505InitListChecker::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);
1515
1516  if (InitListExpr *Result = dyn_cast_or_null<InitListExpr>(ExistingInit))
1517    return Result;
1518
1519  if (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:
1524    //
1525    // struct X { int a, b; };
1526    // struct X xs[] = { [0] = (struct X) { 1, 2 }, [0].b = 3 };
1527    //
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)
1533      << InitRange;
1534    SemaRef.Diag(ExistingInit->getSourceRange().getBegin(),
1535                  diag::note_previous_initializer)
1536      << /*FIXME:has side effects=*/0
1537      << ExistingInit->getSourceRange();
1538  }
1539
1540  InitListExpr *Result
1541    = new (SemaRef.Context) InitListExpr(InitRange.getBegin(), 0, 0,
1542                                         InitRange.getEnd());
1543
1544  Result->setType(CurrentObjectType);
1545
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();
1554  }
1555
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)
1563        NumElements = 0;
1564    }
1565  } else if (const VectorType *VType = CurrentObjectType->getAsVectorType())
1566    NumElements = VType->getNumElements();
1567  else if (const RecordType *RType = CurrentObjectType->getAs<RecordType>()) {
1568    RecordDecl *RDecl = RType->getDecl();
1569    if (RDecl->isUnion())
1570      NumElements = 1;
1571    else
1572      NumElements = std::distance(RDecl->field_begin(),
1573                                  RDecl->field_end());
1574  }
1575
1576  if (NumElements < NumInits)
1577    NumElements = IList->getNumInits();
1578
1579  Result->reserveInits(NumElements);
1580
1581  // Link this new initializer list into the structured initializer
1582  // lists.
1583  if (StructuredList)
1584    StructuredList->updateInit(StructuredIndex, Result);
1585  else {
1586    Result->setSyntacticForm(IList);
1587    SyntacticToSemantic[IList] = Result;
1588  }
1589
1590  return Result;
1591}
1592
1593/// Update the initializer at index @p StructuredIndex within the
1594/// structured initializer list to the value @p expr.
1595void InitListChecker::UpdateStructuredListElement(InitListExpr *StructuredList,
1596                                                  unsigned &StructuredIndex,
1597                                                  Expr *expr) {
1598  // No structured initializer list to update
1599  if (!StructuredList)
1600    return;
1601
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();
1611  }
1612
1613  ++StructuredIndex;
1614}
1615
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
1622/// expression.
1623static bool
1624CheckArrayDesignatorExpr(Sema &S, Expr *Index, llvm::APSInt &Value) {
1625  SourceLocation Loc = Index->getSourceRange().getBegin();
1626
1627  // Make sure this is an integer constant expression.
1628  if (S.VerifyIntegerConstantExpression(Index, &Value))
1629    return true;
1630
1631  if (Value.isSigned() && Value.isNegative())
1632    return S.Diag(Loc, diag::err_array_designator_negative)
1633      << Value.toString(10) << Index->getSourceRange();
1634
1635  Value.setIsUnsigned(true);
1636  return false;
1637}
1638
1639Sema::OwningExprResult Sema::ActOnDesignatedInitializer(Designation &Desig,
1640                                                        SourceLocation Loc,
1641                                                        bool GNUSyntax,
1642                                                        OwningExprResult Init) {
1643  typedef DesignatedInitExpr::Designator ASTDesignator;
1644
1645  bool Invalid = false;
1646  llvm::SmallVector<ASTDesignator, 32> Designators;
1647  llvm::SmallVector<Expr *, 32> InitExpressions;
1648
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(),
1655                                          D.getFieldLoc()));
1656      break;
1657
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))
1664        Invalid = true;
1665      else {
1666        Designators.push_back(ASTDesignator(InitExpressions.size(),
1667                                            D.getLBracketLoc(),
1668                                            D.getRBracketLoc()));
1669        InitExpressions.push_back(Index);
1670      }
1671      break;
1672    }
1673
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)) ||
1685          (!EndDependent &&
1686           CheckArrayDesignatorExpr(*this, EndIndex, EndValue)))
1687        Invalid = true;
1688      else {
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());
1696
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();
1701          Invalid = true;
1702        } else {
1703          Designators.push_back(ASTDesignator(InitExpressions.size(),
1704                                              D.getLBracketLoc(),
1705                                              D.getEllipsisLoc(),
1706                                              D.getRBracketLoc()));
1707          InitExpressions.push_back(StartIndex);
1708          InitExpressions.push_back(EndIndex);
1709        }
1710      }
1711      break;
1712    }
1713    }
1714  }
1715
1716  if (Invalid || Init.isInvalid())
1717    return ExprError();
1718
1719  // Clear out the expressions within the designation.
1720  Desig.ClearExprs(*this);
1721
1722  DesignatedInitExpr *DIE
1723    = DesignatedInitExpr::Create(Context,
1724                                 Designators.data(), Designators.size(),
1725                                 InitExpressions.data(), InitExpressions.size(),
1726                                 Loc, GNUSyntax, Init.takeAs<Expr>());
1727  return Owned(DIE);
1728}
1729
1730bool Sema::CheckInitList(InitListExpr *&InitList, QualType &DeclType) {
1731  InitListChecker CheckInitList(*this, InitList, DeclType);
1732  if (!CheckInitList.HadError())
1733    InitList = CheckInitList.getFullyStructuredList();
1734
1735  return CheckInitList.HadError();
1736}
1737
1738/// \brief Diagnose any semantic errors with value-initialization of
1739/// the given type.
1740///
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.
1750///
1751/// \returns true if there was an error, false otherwise.
1752bool Sema::CheckValueInitialization(QualType Type, SourceLocation Loc) {
1753  // C++ [dcl.init]p5:
1754  //
1755  //   To value-initialize an object of type T means:
1756
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);
1760
1761  if (const RecordType *RT = Type->getAs<RecordType>()) {
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
1769        // AST.
1770        return PerformInitializationByConstructor(Type, 0, 0, Loc,
1771                                                  SourceRange(Loc),
1772                                                  DeclarationName(),
1773                                                  IK_Direct);
1774    }
1775  }
1776
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
1783    // diagnostic :)
1784  }
1785
1786  return false;
1787}
1788