SemaDecl.cpp revision ef65f06e8e440aec541442cfd73a8a836e9bc842
1//===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
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 declarations.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "SemaInherit.h"
16#include "clang/AST/APValue.h"
17#include "clang/AST/ASTConsumer.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
21#include "clang/AST/ExprCXX.h"
22#include "clang/AST/StmtCXX.h"
23#include "clang/Parse/DeclSpec.h"
24#include "clang/Basic/TargetInfo.h"
25#include "clang/Basic/SourceManager.h"
26// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
27#include "clang/Lex/Preprocessor.h"
28#include "clang/Lex/HeaderSearch.h"
29#include "llvm/ADT/SmallSet.h"
30#include "llvm/ADT/STLExtras.h"
31#include <algorithm>
32#include <functional>
33using namespace clang;
34
35/// getDeclName - Return a pretty name for the specified decl if possible, or
36/// an empty string if not.  This is used for pretty crash reporting.
37std::string Sema::getDeclName(DeclPtrTy d) {
38  Decl *D = d.getAs<Decl>();
39  if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
40    return DN->getQualifiedNameAsString();
41  return "";
42}
43
44Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
45  return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
46}
47
48/// \brief If the identifier refers to a type name within this scope,
49/// return the declaration of that type.
50///
51/// This routine performs ordinary name lookup of the identifier II
52/// within the given scope, with optional C++ scope specifier SS, to
53/// determine whether the name refers to a type. If so, returns an
54/// opaque pointer (actually a QualType) corresponding to that
55/// type. Otherwise, returns NULL.
56///
57/// If name lookup results in an ambiguity, this routine will complain
58/// and then return NULL.
59Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
60                                Scope *S, const CXXScopeSpec *SS) {
61  // C++ [temp.res]p3:
62  //   A qualified-id that refers to a type and in which the
63  //   nested-name-specifier depends on a template-parameter (14.6.2)
64  //   shall be prefixed by the keyword typename to indicate that the
65  //   qualified-id denotes a type, forming an
66  //   elaborated-type-specifier (7.1.5.3).
67  //
68  // We therefore do not perform any name lookup if the result would
69  // refer to a member of an unknown specialization.
70  if (SS && isUnknownSpecialization(*SS))
71    return 0;
72
73  LookupResult Result
74    = LookupParsedName(S, SS, &II, LookupOrdinaryName, false, false);
75
76  NamedDecl *IIDecl = 0;
77  switch (Result.getKind()) {
78  case LookupResult::NotFound:
79  case LookupResult::FoundOverloaded:
80    return 0;
81
82  case LookupResult::AmbiguousBaseSubobjectTypes:
83  case LookupResult::AmbiguousBaseSubobjects:
84  case LookupResult::AmbiguousReference: {
85    // Look to see if we have a type anywhere in the list of results.
86    for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
87         Res != ResEnd; ++Res) {
88      if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
89        if (!IIDecl ||
90            (*Res)->getLocation().getRawEncoding() <
91              IIDecl->getLocation().getRawEncoding())
92          IIDecl = *Res;
93      }
94    }
95
96    if (!IIDecl) {
97      // None of the entities we found is a type, so there is no way
98      // to even assume that the result is a type. In this case, don't
99      // complain about the ambiguity. The parser will either try to
100      // perform this lookup again (e.g., as an object name), which
101      // will produce the ambiguity, or will complain that it expected
102      // a type name.
103      Result.Destroy();
104      return 0;
105    }
106
107    // We found a type within the ambiguous lookup; diagnose the
108    // ambiguity and then return that type. This might be the right
109    // answer, or it might not be, but it suppresses any attempt to
110    // perform the name lookup again.
111    DiagnoseAmbiguousLookup(Result, DeclarationName(&II), NameLoc);
112    break;
113  }
114
115  case LookupResult::Found:
116    IIDecl = Result.getAsDecl();
117    break;
118  }
119
120  if (IIDecl) {
121    QualType T;
122
123    if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
124      // Check whether we can use this type
125      (void)DiagnoseUseOfDecl(IIDecl, NameLoc);
126
127      if (getLangOptions().CPlusPlus) {
128        // C++ [temp.local]p2:
129        //   Within the scope of a class template specialization or
130        //   partial specialization, when the injected-class-name is
131        //   not followed by a <, it is equivalent to the
132        //   injected-class-name followed by the template-argument s
133        //   of the class template specialization or partial
134        //   specialization enclosed in <>.
135        if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
136          if (RD->isInjectedClassName())
137            if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
138              T = Template->getInjectedClassNameType(Context);
139      }
140
141      if (T.isNull())
142        T = Context.getTypeDeclType(TD);
143    } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
144      // Check whether we can use this interface.
145      (void)DiagnoseUseOfDecl(IIDecl, NameLoc);
146
147      T = Context.getObjCInterfaceType(IDecl);
148    } else
149      return 0;
150
151    if (SS)
152      T = getQualifiedNameType(*SS, T);
153
154    return T.getAsOpaquePtr();
155  }
156
157  return 0;
158}
159
160/// isTagName() - This method is called *for error recovery purposes only*
161/// to determine if the specified name is a valid tag name ("struct foo").  If
162/// so, this returns the TST for the tag corresponding to it (TST_enum,
163/// TST_union, TST_struct, TST_class).  This is used to diagnose cases in C
164/// where the user forgot to specify the tag.
165DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
166  // Do a tag name lookup in this scope.
167  LookupResult R = LookupName(S, &II, LookupTagName, false, false);
168  if (R.getKind() == LookupResult::Found)
169    if (const TagDecl *TD = dyn_cast<TagDecl>(R.getAsDecl())) {
170      switch (TD->getTagKind()) {
171      case TagDecl::TK_struct: return DeclSpec::TST_struct;
172      case TagDecl::TK_union:  return DeclSpec::TST_union;
173      case TagDecl::TK_class:  return DeclSpec::TST_class;
174      case TagDecl::TK_enum:   return DeclSpec::TST_enum;
175      }
176    }
177
178  return DeclSpec::TST_unspecified;
179}
180
181
182
183DeclContext *Sema::getContainingDC(DeclContext *DC) {
184  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) {
185    // A C++ out-of-line method will return to the file declaration context.
186    if (MD->isOutOfLineDefinition())
187      return MD->getLexicalDeclContext();
188
189    // A C++ inline method is parsed *after* the topmost class it was declared
190    // in is fully parsed (it's "complete").
191    // The parsing of a C++ inline method happens at the declaration context of
192    // the topmost (non-nested) class it is lexically declared in.
193    assert(isa<CXXRecordDecl>(MD->getParent()) && "C++ method not in Record.");
194    DC = MD->getParent();
195    while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
196      DC = RD;
197
198    // Return the declaration context of the topmost class the inline method is
199    // declared in.
200    return DC;
201  }
202
203  if (isa<ObjCMethodDecl>(DC))
204    return Context.getTranslationUnitDecl();
205
206  return DC->getLexicalParent();
207}
208
209void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
210  assert(getContainingDC(DC) == CurContext &&
211      "The next DeclContext should be lexically contained in the current one.");
212  CurContext = DC;
213  S->setEntity(DC);
214}
215
216void Sema::PopDeclContext() {
217  assert(CurContext && "DeclContext imbalance!");
218
219  CurContext = getContainingDC(CurContext);
220}
221
222/// \brief Determine whether we allow overloading of the function
223/// PrevDecl with another declaration.
224///
225/// This routine determines whether overloading is possible, not
226/// whether some new function is actually an overload. It will return
227/// true in C++ (where we can always provide overloads) or, as an
228/// extension, in C when the previous function is already an
229/// overloaded function declaration or has the "overloadable"
230/// attribute.
231static bool AllowOverloadingOfFunction(Decl *PrevDecl, ASTContext &Context) {
232  if (Context.getLangOptions().CPlusPlus)
233    return true;
234
235  if (isa<OverloadedFunctionDecl>(PrevDecl))
236    return true;
237
238  return PrevDecl->getAttr<OverloadableAttr>() != 0;
239}
240
241/// Add this decl to the scope shadowed decl chains.
242void Sema::PushOnScopeChains(NamedDecl *D, Scope *S) {
243  // Move up the scope chain until we find the nearest enclosing
244  // non-transparent context. The declaration will be introduced into this
245  // scope.
246  while (S->getEntity() &&
247         ((DeclContext *)S->getEntity())->isTransparentContext())
248    S = S->getParent();
249
250  S->AddDecl(DeclPtrTy::make(D));
251
252  // Add scoped declarations into their context, so that they can be
253  // found later. Declarations without a context won't be inserted
254  // into any context.
255  CurContext->addDecl(Context, D);
256
257  // C++ [basic.scope]p4:
258  //   -- exactly one declaration shall declare a class name or
259  //   enumeration name that is not a typedef name and the other
260  //   declarations shall all refer to the same object or
261  //   enumerator, or all refer to functions and function templates;
262  //   in this case the class name or enumeration name is hidden.
263  if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
264    // We are pushing the name of a tag (enum or class).
265    if (CurContext->getLookupContext()
266          == TD->getDeclContext()->getLookupContext()) {
267      // We're pushing the tag into the current context, which might
268      // require some reshuffling in the identifier resolver.
269      IdentifierResolver::iterator
270        I = IdResolver.begin(TD->getDeclName()),
271        IEnd = IdResolver.end();
272      if (I != IEnd && isDeclInScope(*I, CurContext, S)) {
273        NamedDecl *PrevDecl = *I;
274        for (; I != IEnd && isDeclInScope(*I, CurContext, S);
275             PrevDecl = *I, ++I) {
276          if (TD->declarationReplaces(*I)) {
277            // This is a redeclaration. Remove it from the chain and
278            // break out, so that we'll add in the shadowed
279            // declaration.
280            S->RemoveDecl(DeclPtrTy::make(*I));
281            if (PrevDecl == *I) {
282              IdResolver.RemoveDecl(*I);
283              IdResolver.AddDecl(TD);
284              return;
285            } else {
286              IdResolver.RemoveDecl(*I);
287              break;
288            }
289          }
290        }
291
292        // There is already a declaration with the same name in the same
293        // scope, which is not a tag declaration. It must be found
294        // before we find the new declaration, so insert the new
295        // declaration at the end of the chain.
296        IdResolver.AddShadowedDecl(TD, PrevDecl);
297
298        return;
299      }
300    }
301  } else if (isa<FunctionDecl>(D) &&
302             AllowOverloadingOfFunction(D, Context)) {
303    // We are pushing the name of a function, which might be an
304    // overloaded name.
305    FunctionDecl *FD = cast<FunctionDecl>(D);
306    IdentifierResolver::iterator Redecl
307      = std::find_if(IdResolver.begin(FD->getDeclName()),
308                     IdResolver.end(),
309                     std::bind1st(std::mem_fun(&NamedDecl::declarationReplaces),
310                                  FD));
311    if (Redecl != IdResolver.end() &&
312        S->isDeclScope(DeclPtrTy::make(*Redecl))) {
313      // There is already a declaration of a function on our
314      // IdResolver chain. Replace it with this declaration.
315      S->RemoveDecl(DeclPtrTy::make(*Redecl));
316      IdResolver.RemoveDecl(*Redecl);
317    }
318  } else if (isa<ObjCInterfaceDecl>(D)) {
319    // We're pushing an Objective-C interface into the current
320    // context. If there is already an alias declaration, remove it first.
321    for (IdentifierResolver::iterator
322           I = IdResolver.begin(D->getDeclName()), IEnd = IdResolver.end();
323         I != IEnd; ++I) {
324      if (isa<ObjCCompatibleAliasDecl>(*I)) {
325        S->RemoveDecl(DeclPtrTy::make(*I));
326        IdResolver.RemoveDecl(*I);
327        break;
328      }
329    }
330  }
331
332  IdResolver.AddDecl(D);
333}
334
335void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
336  if (S->decl_empty()) return;
337  assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
338	 "Scope shouldn't contain decls!");
339
340  for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
341       I != E; ++I) {
342    Decl *TmpD = (*I).getAs<Decl>();
343    assert(TmpD && "This decl didn't get pushed??");
344
345    assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
346    NamedDecl *D = cast<NamedDecl>(TmpD);
347
348    if (!D->getDeclName()) continue;
349
350    // Remove this name from our lexical scope.
351    IdResolver.RemoveDecl(D);
352  }
353}
354
355/// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
356/// return 0 if one not found.
357ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) {
358  // The third "scope" argument is 0 since we aren't enabling lazy built-in
359  // creation from this context.
360  NamedDecl *IDecl = LookupName(TUScope, Id, LookupOrdinaryName);
361
362  return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
363}
364
365/// getNonFieldDeclScope - Retrieves the innermost scope, starting
366/// from S, where a non-field would be declared. This routine copes
367/// with the difference between C and C++ scoping rules in structs and
368/// unions. For example, the following code is well-formed in C but
369/// ill-formed in C++:
370/// @code
371/// struct S6 {
372///   enum { BAR } e;
373/// };
374///
375/// void test_S6() {
376///   struct S6 a;
377///   a.e = BAR;
378/// }
379/// @endcode
380/// For the declaration of BAR, this routine will return a different
381/// scope. The scope S will be the scope of the unnamed enumeration
382/// within S6. In C++, this routine will return the scope associated
383/// with S6, because the enumeration's scope is a transparent
384/// context but structures can contain non-field names. In C, this
385/// routine will return the translation unit scope, since the
386/// enumeration's scope is a transparent context and structures cannot
387/// contain non-field names.
388Scope *Sema::getNonFieldDeclScope(Scope *S) {
389  while (((S->getFlags() & Scope::DeclScope) == 0) ||
390         (S->getEntity() &&
391          ((DeclContext *)S->getEntity())->isTransparentContext()) ||
392         (S->isClassScope() && !getLangOptions().CPlusPlus))
393    S = S->getParent();
394  return S;
395}
396
397void Sema::InitBuiltinVaListType() {
398  if (!Context.getBuiltinVaListType().isNull())
399    return;
400
401  IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
402  NamedDecl *VaDecl = LookupName(TUScope, VaIdent, LookupOrdinaryName);
403  TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
404  Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
405}
406
407/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
408/// file scope.  lazily create a decl for it. ForRedeclaration is true
409/// if we're creating this built-in in anticipation of redeclaring the
410/// built-in.
411NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
412                                     Scope *S, bool ForRedeclaration,
413                                     SourceLocation Loc) {
414  Builtin::ID BID = (Builtin::ID)bid;
415
416  if (Context.BuiltinInfo.hasVAListUse(BID))
417    InitBuiltinVaListType();
418
419  Builtin::Context::GetBuiltinTypeError Error;
420  QualType R = Context.BuiltinInfo.GetBuiltinType(BID, Context, Error);
421  switch (Error) {
422  case Builtin::Context::GE_None:
423    // Okay
424    break;
425
426  case Builtin::Context::GE_Missing_FILE:
427    if (ForRedeclaration)
428      Diag(Loc, diag::err_implicit_decl_requires_stdio)
429        << Context.BuiltinInfo.GetName(BID);
430    return 0;
431  }
432
433  if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
434    Diag(Loc, diag::ext_implicit_lib_function_decl)
435      << Context.BuiltinInfo.GetName(BID)
436      << R;
437    if (Context.BuiltinInfo.getHeaderName(BID) &&
438        Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
439          != Diagnostic::Ignored)
440      Diag(Loc, diag::note_please_include_header)
441        << Context.BuiltinInfo.getHeaderName(BID)
442        << Context.BuiltinInfo.GetName(BID);
443  }
444
445  FunctionDecl *New = FunctionDecl::Create(Context,
446                                           Context.getTranslationUnitDecl(),
447                                           Loc, II, R,
448                                           FunctionDecl::Extern, false,
449                                           /*hasPrototype=*/true);
450  New->setImplicit();
451
452  // Create Decl objects for each parameter, adding them to the
453  // FunctionDecl.
454  if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
455    llvm::SmallVector<ParmVarDecl*, 16> Params;
456    for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
457      Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
458                                           FT->getArgType(i), VarDecl::None, 0));
459    New->setParams(Context, Params.data(), Params.size());
460  }
461
462  AddKnownFunctionAttributes(New);
463
464  // TUScope is the translation-unit scope to insert this function into.
465  // FIXME: This is hideous. We need to teach PushOnScopeChains to
466  // relate Scopes to DeclContexts, and probably eliminate CurContext
467  // entirely, but we're not there yet.
468  DeclContext *SavedContext = CurContext;
469  CurContext = Context.getTranslationUnitDecl();
470  PushOnScopeChains(New, TUScope);
471  CurContext = SavedContext;
472  return New;
473}
474
475/// GetStdNamespace - This method gets the C++ "std" namespace. This is where
476/// everything from the standard library is defined.
477NamespaceDecl *Sema::GetStdNamespace() {
478  if (!StdNamespace) {
479    IdentifierInfo *StdIdent = &PP.getIdentifierTable().get("std");
480    DeclContext *Global = Context.getTranslationUnitDecl();
481    Decl *Std = LookupQualifiedName(Global, StdIdent, LookupNamespaceName);
482    StdNamespace = dyn_cast_or_null<NamespaceDecl>(Std);
483  }
484  return StdNamespace;
485}
486
487/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
488/// same name and scope as a previous declaration 'Old'.  Figure out
489/// how to resolve this situation, merging decls or emitting
490/// diagnostics as appropriate. If there was an error, set New to be invalid.
491///
492void Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
493  // If either decl is known invalid already, set the new one to be invalid and
494  // don't bother doing any merging checks.
495  if (New->isInvalidDecl() || OldD->isInvalidDecl())
496    return New->setInvalidDecl();
497
498  bool objc_types = false;
499
500  // Allow multiple definitions for ObjC built-in typedefs.
501  // FIXME: Verify the underlying types are equivalent!
502  if (getLangOptions().ObjC1) {
503    const IdentifierInfo *TypeID = New->getIdentifier();
504    switch (TypeID->getLength()) {
505    default: break;
506    case 2:
507      if (!TypeID->isStr("id"))
508        break;
509      Context.setObjCIdType(Context.getTypeDeclType(New));
510      objc_types = true;
511      break;
512    case 5:
513      if (!TypeID->isStr("Class"))
514        break;
515      Context.setObjCClassType(Context.getTypeDeclType(New));
516      return;
517    case 3:
518      if (!TypeID->isStr("SEL"))
519        break;
520      Context.setObjCSelType(Context.getTypeDeclType(New));
521      return;
522    case 8:
523      if (!TypeID->isStr("Protocol"))
524        break;
525      Context.setObjCProtoType(New->getUnderlyingType());
526      return;
527    }
528    // Fall through - the typedef name was not a builtin type.
529  }
530  // Verify the old decl was also a type.
531  TypeDecl *Old = dyn_cast<TypeDecl>(OldD);
532  if (!Old) {
533    Diag(New->getLocation(), diag::err_redefinition_different_kind)
534      << New->getDeclName();
535    if (OldD->getLocation().isValid())
536      Diag(OldD->getLocation(), diag::note_previous_definition);
537    return New->setInvalidDecl();
538  }
539
540  // Determine the "old" type we'll use for checking and diagnostics.
541  QualType OldType;
542  if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
543    OldType = OldTypedef->getUnderlyingType();
544  else
545    OldType = Context.getTypeDeclType(Old);
546
547  // If the typedef types are not identical, reject them in all languages and
548  // with any extensions enabled.
549
550  if (OldType != New->getUnderlyingType() &&
551      Context.getCanonicalType(OldType) !=
552      Context.getCanonicalType(New->getUnderlyingType())) {
553    Diag(New->getLocation(), diag::err_redefinition_different_typedef)
554      << New->getUnderlyingType() << OldType;
555    if (Old->getLocation().isValid())
556      Diag(Old->getLocation(), diag::note_previous_definition);
557    return New->setInvalidDecl();
558  }
559
560  if (objc_types || getLangOptions().Microsoft)
561    return;
562
563  // C++ [dcl.typedef]p2:
564  //   In a given non-class scope, a typedef specifier can be used to
565  //   redefine the name of any type declared in that scope to refer
566  //   to the type to which it already refers.
567  if (getLangOptions().CPlusPlus) {
568    if (!isa<CXXRecordDecl>(CurContext))
569      return;
570    Diag(New->getLocation(), diag::err_redefinition)
571      << New->getDeclName();
572    Diag(Old->getLocation(), diag::note_previous_definition);
573    return New->setInvalidDecl();
574  }
575
576  // If we have a redefinition of a typedef in C, emit a warning.  This warning
577  // is normally mapped to an error, but can be controlled with
578  // -Wtypedef-redefinition.  If either the original was in a system header,
579  // don't emit this for compatibility with GCC.
580  if (PP.getDiagnostics().getSuppressSystemWarnings() &&
581      Context.getSourceManager().isInSystemHeader(Old->getLocation()))
582    return;
583
584  Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
585    << New->getDeclName();
586  Diag(Old->getLocation(), diag::note_previous_definition);
587  return;
588}
589
590/// DeclhasAttr - returns true if decl Declaration already has the target
591/// attribute.
592static bool DeclHasAttr(const Decl *decl, const Attr *target) {
593  for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
594    if (attr->getKind() == target->getKind())
595      return true;
596
597  return false;
598}
599
600/// MergeAttributes - append attributes from the Old decl to the New one.
601static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
602  for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
603    if (!DeclHasAttr(New, attr) && attr->isMerged()) {
604      Attr *NewAttr = attr->clone(C);
605      NewAttr->setInherited(true);
606      New->addAttr(NewAttr);
607    }
608  }
609}
610
611/// Used in MergeFunctionDecl to keep track of function parameters in
612/// C.
613struct GNUCompatibleParamWarning {
614  ParmVarDecl *OldParm;
615  ParmVarDecl *NewParm;
616  QualType PromotedType;
617};
618
619/// MergeFunctionDecl - We just parsed a function 'New' from
620/// declarator D which has the same name and scope as a previous
621/// declaration 'Old'.  Figure out how to resolve this situation,
622/// merging decls or emitting diagnostics as appropriate.
623///
624/// In C++, New and Old must be declarations that are not
625/// overloaded. Use IsOverload to determine whether New and Old are
626/// overloaded, and to select the Old declaration that New should be
627/// merged with.
628///
629/// Returns true if there was an error, false otherwise.
630bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
631  assert(!isa<OverloadedFunctionDecl>(OldD) &&
632         "Cannot merge with an overloaded function declaration");
633
634  // Verify the old decl was also a function.
635  FunctionDecl *Old = dyn_cast<FunctionDecl>(OldD);
636  if (!Old) {
637    Diag(New->getLocation(), diag::err_redefinition_different_kind)
638      << New->getDeclName();
639    Diag(OldD->getLocation(), diag::note_previous_definition);
640    return true;
641  }
642
643  // Determine whether the previous declaration was a definition,
644  // implicit declaration, or a declaration.
645  diag::kind PrevDiag;
646  if (Old->isThisDeclarationADefinition())
647    PrevDiag = diag::note_previous_definition;
648  else if (Old->isImplicit())
649    PrevDiag = diag::note_previous_implicit_declaration;
650  else
651    PrevDiag = diag::note_previous_declaration;
652
653  QualType OldQType = Context.getCanonicalType(Old->getType());
654  QualType NewQType = Context.getCanonicalType(New->getType());
655
656  if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
657      New->getStorageClass() == FunctionDecl::Static &&
658      Old->getStorageClass() != FunctionDecl::Static) {
659    Diag(New->getLocation(), diag::err_static_non_static)
660      << New;
661    Diag(Old->getLocation(), PrevDiag);
662    return true;
663  }
664
665  if (getLangOptions().CPlusPlus) {
666    // (C++98 13.1p2):
667    //   Certain function declarations cannot be overloaded:
668    //     -- Function declarations that differ only in the return type
669    //        cannot be overloaded.
670    QualType OldReturnType
671      = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
672    QualType NewReturnType
673      = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
674    if (OldReturnType != NewReturnType) {
675      Diag(New->getLocation(), diag::err_ovl_diff_return_type);
676      Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
677      return true;
678    }
679
680    const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
681    const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
682    if (OldMethod && NewMethod &&
683        OldMethod->getLexicalDeclContext() ==
684          NewMethod->getLexicalDeclContext()) {
685      //    -- Member function declarations with the same name and the
686      //       same parameter types cannot be overloaded if any of them
687      //       is a static member function declaration.
688      if (OldMethod->isStatic() || NewMethod->isStatic()) {
689        Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
690        Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
691        return true;
692      }
693
694      // C++ [class.mem]p1:
695      //   [...] A member shall not be declared twice in the
696      //   member-specification, except that a nested class or member
697      //   class template can be declared and then later defined.
698      unsigned NewDiag;
699      if (isa<CXXConstructorDecl>(OldMethod))
700        NewDiag = diag::err_constructor_redeclared;
701      else if (isa<CXXDestructorDecl>(NewMethod))
702        NewDiag = diag::err_destructor_redeclared;
703      else if (isa<CXXConversionDecl>(NewMethod))
704        NewDiag = diag::err_conv_function_redeclared;
705      else
706        NewDiag = diag::err_member_redeclared;
707
708      Diag(New->getLocation(), NewDiag);
709      Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
710    }
711
712    // (C++98 8.3.5p3):
713    //   All declarations for a function shall agree exactly in both the
714    //   return type and the parameter-type-list.
715    if (OldQType == NewQType)
716      return MergeCompatibleFunctionDecls(New, Old);
717
718    // Fall through for conflicting redeclarations and redefinitions.
719  }
720
721  // C: Function types need to be compatible, not identical. This handles
722  // duplicate function decls like "void f(int); void f(enum X);" properly.
723  if (!getLangOptions().CPlusPlus &&
724      Context.typesAreCompatible(OldQType, NewQType)) {
725    const FunctionType *OldFuncType = OldQType->getAsFunctionType();
726    const FunctionType *NewFuncType = NewQType->getAsFunctionType();
727    const FunctionProtoType *OldProto = 0;
728    if (isa<FunctionNoProtoType>(NewFuncType) &&
729        (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
730      // The old declaration provided a function prototype, but the
731      // new declaration does not. Merge in the prototype.
732      assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
733      llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
734                                                 OldProto->arg_type_end());
735      NewQType = Context.getFunctionType(NewFuncType->getResultType(),
736                                         ParamTypes.data(), ParamTypes.size(),
737                                         OldProto->isVariadic(),
738                                         OldProto->getTypeQuals());
739      New->setType(NewQType);
740      New->setHasInheritedPrototype();
741
742      // Synthesize a parameter for each argument type.
743      llvm::SmallVector<ParmVarDecl*, 16> Params;
744      for (FunctionProtoType::arg_type_iterator
745             ParamType = OldProto->arg_type_begin(),
746             ParamEnd = OldProto->arg_type_end();
747           ParamType != ParamEnd; ++ParamType) {
748        ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
749                                                 SourceLocation(), 0,
750                                                 *ParamType, VarDecl::None,
751                                                 0);
752        Param->setImplicit();
753        Params.push_back(Param);
754      }
755
756      New->setParams(Context, Params.data(), Params.size());
757    }
758
759    return MergeCompatibleFunctionDecls(New, Old);
760  }
761
762  // GNU C permits a K&R definition to follow a prototype declaration
763  // if the declared types of the parameters in the K&R definition
764  // match the types in the prototype declaration, even when the
765  // promoted types of the parameters from the K&R definition differ
766  // from the types in the prototype. GCC then keeps the types from
767  // the prototype.
768  if (!getLangOptions().CPlusPlus &&
769      Old->hasPrototype() && !New->hasPrototype() &&
770      New->getType()->getAsFunctionProtoType() &&
771      Old->getNumParams() == New->getNumParams()) {
772    llvm::SmallVector<QualType, 16> ArgTypes;
773    llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
774    const FunctionProtoType *OldProto
775      = Old->getType()->getAsFunctionProtoType();
776    const FunctionProtoType *NewProto
777      = New->getType()->getAsFunctionProtoType();
778
779    // Determine whether this is the GNU C extension.
780    bool GNUCompatible =
781      Context.typesAreCompatible(OldProto->getResultType(),
782                                 NewProto->getResultType()) &&
783      (OldProto->isVariadic() == NewProto->isVariadic());
784    for (unsigned Idx = 0, End = Old->getNumParams();
785         GNUCompatible && Idx != End; ++Idx) {
786      ParmVarDecl *OldParm = Old->getParamDecl(Idx);
787      ParmVarDecl *NewParm = New->getParamDecl(Idx);
788      if (Context.typesAreCompatible(OldParm->getType(),
789                                     NewProto->getArgType(Idx))) {
790        ArgTypes.push_back(NewParm->getType());
791      } else if (Context.typesAreCompatible(OldParm->getType(),
792                                            NewParm->getType())) {
793        GNUCompatibleParamWarning Warn
794          = { OldParm, NewParm, NewProto->getArgType(Idx) };
795        Warnings.push_back(Warn);
796        ArgTypes.push_back(NewParm->getType());
797      } else
798        GNUCompatible = false;
799    }
800
801    if (GNUCompatible) {
802      for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
803        Diag(Warnings[Warn].NewParm->getLocation(),
804             diag::ext_param_promoted_not_compatible_with_prototype)
805          << Warnings[Warn].PromotedType
806          << Warnings[Warn].OldParm->getType();
807        Diag(Warnings[Warn].OldParm->getLocation(),
808             diag::note_previous_declaration);
809      }
810
811      New->setType(Context.getFunctionType(NewProto->getResultType(),
812                                           &ArgTypes[0], ArgTypes.size(),
813                                           NewProto->isVariadic(),
814                                           NewProto->getTypeQuals()));
815      return MergeCompatibleFunctionDecls(New, Old);
816    }
817
818    // Fall through to diagnose conflicting types.
819  }
820
821  // A function that has already been declared has been redeclared or defined
822  // with a different type- show appropriate diagnostic
823  if (unsigned BuiltinID = Old->getBuiltinID(Context)) {
824    // The user has declared a builtin function with an incompatible
825    // signature.
826    if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
827      // The function the user is redeclaring is a library-defined
828      // function like 'malloc' or 'printf'. Warn about the
829      // redeclaration, then pretend that we don't know about this
830      // library built-in.
831      Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
832      Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
833        << Old << Old->getType();
834      New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
835      Old->setInvalidDecl();
836      return false;
837    }
838
839    PrevDiag = diag::note_previous_builtin_declaration;
840  }
841
842  Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
843  Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
844  return true;
845}
846
847/// \brief Completes the merge of two function declarations that are
848/// known to be compatible.
849///
850/// This routine handles the merging of attributes and other
851/// properties of function declarations form the old declaration to
852/// the new declaration, once we know that New is in fact a
853/// redeclaration of Old.
854///
855/// \returns false
856bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
857  // Merge the attributes
858  MergeAttributes(New, Old, Context);
859
860  // Merge the storage class.
861  if (Old->getStorageClass() != FunctionDecl::Extern)
862    New->setStorageClass(Old->getStorageClass());
863
864  // Merge "inline"
865  if (Old->isInline())
866    New->setInline(true);
867
868  // If this function declaration by itself qualifies as a C99 inline
869  // definition (C99 6.7.4p6), but the previous definition did not,
870  // then the function is not a C99 inline definition.
871  if (New->isC99InlineDefinition() && !Old->isC99InlineDefinition())
872    New->setC99InlineDefinition(false);
873  else if (Old->isC99InlineDefinition() && !New->isC99InlineDefinition()) {
874    // Mark all preceding definitions as not being C99 inline definitions.
875    for (const FunctionDecl *Prev = Old; Prev;
876         Prev = Prev->getPreviousDeclaration())
877      const_cast<FunctionDecl *>(Prev)->setC99InlineDefinition(false);
878  }
879
880  // Merge "pure" flag.
881  if (Old->isPure())
882    New->setPure();
883
884  // Merge the "deleted" flag.
885  if (Old->isDeleted())
886    New->setDeleted();
887
888  if (getLangOptions().CPlusPlus)
889    return MergeCXXFunctionDecl(New, Old);
890
891  return false;
892}
893
894/// MergeVarDecl - We just parsed a variable 'New' which has the same name
895/// and scope as a previous declaration 'Old'.  Figure out how to resolve this
896/// situation, merging decls or emitting diagnostics as appropriate.
897///
898/// Tentative definition rules (C99 6.9.2p2) are checked by
899/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
900/// definitions here, since the initializer hasn't been attached.
901///
902void Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
903  // If either decl is invalid, make sure the new one is marked invalid and
904  // don't do any other checking.
905  if (New->isInvalidDecl() || OldD->isInvalidDecl())
906    return New->setInvalidDecl();
907
908  // Verify the old decl was also a variable.
909  VarDecl *Old = dyn_cast<VarDecl>(OldD);
910  if (!Old) {
911    Diag(New->getLocation(), diag::err_redefinition_different_kind)
912      << New->getDeclName();
913    Diag(OldD->getLocation(), diag::note_previous_definition);
914    return New->setInvalidDecl();
915  }
916
917  MergeAttributes(New, Old, Context);
918
919  // Merge the types
920  QualType MergedT;
921  if (getLangOptions().CPlusPlus) {
922    if (Context.hasSameType(New->getType(), Old->getType()))
923      MergedT = New->getType();
924  } else {
925    MergedT = Context.mergeTypes(New->getType(), Old->getType());
926  }
927  if (MergedT.isNull()) {
928    Diag(New->getLocation(), diag::err_redefinition_different_type)
929      << New->getDeclName();
930    Diag(Old->getLocation(), diag::note_previous_definition);
931    return New->setInvalidDecl();
932  }
933  New->setType(MergedT);
934
935  // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
936  if (New->getStorageClass() == VarDecl::Static &&
937      (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
938    Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
939    Diag(Old->getLocation(), diag::note_previous_definition);
940    return New->setInvalidDecl();
941  }
942  // C99 6.2.2p4:
943  //   For an identifier declared with the storage-class specifier
944  //   extern in a scope in which a prior declaration of that
945  //   identifier is visible,23) if the prior declaration specifies
946  //   internal or external linkage, the linkage of the identifier at
947  //   the later declaration is the same as the linkage specified at
948  //   the prior declaration. If no prior declaration is visible, or
949  //   if the prior declaration specifies no linkage, then the
950  //   identifier has external linkage.
951  if (New->hasExternalStorage() && Old->hasLinkage())
952    /* Okay */;
953  else if (New->getStorageClass() != VarDecl::Static &&
954           Old->getStorageClass() == VarDecl::Static) {
955    Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
956    Diag(Old->getLocation(), diag::note_previous_definition);
957    return New->setInvalidDecl();
958  }
959
960  // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
961
962  // FIXME: The test for external storage here seems wrong? We still
963  // need to check for mismatches.
964  if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
965      // Don't complain about out-of-line definitions of static members.
966      !(Old->getLexicalDeclContext()->isRecord() &&
967        !New->getLexicalDeclContext()->isRecord())) {
968    Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
969    Diag(Old->getLocation(), diag::note_previous_definition);
970    return New->setInvalidDecl();
971  }
972
973  if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
974    Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
975    Diag(Old->getLocation(), diag::note_previous_definition);
976  } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
977    Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
978    Diag(Old->getLocation(), diag::note_previous_definition);
979  }
980
981  // Keep a chain of previous declarations.
982  New->setPreviousDeclaration(Old);
983}
984
985/// CheckParmsForFunctionDef - Check that the parameters of the given
986/// function are appropriate for the definition of a function. This
987/// takes care of any checks that cannot be performed on the
988/// declaration itself, e.g., that the types of each of the function
989/// parameters are complete.
990bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
991  bool HasInvalidParm = false;
992  for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
993    ParmVarDecl *Param = FD->getParamDecl(p);
994
995    // C99 6.7.5.3p4: the parameters in a parameter type list in a
996    // function declarator that is part of a function definition of
997    // that function shall not have incomplete type.
998    //
999    // This is also C++ [dcl.fct]p6.
1000    if (!Param->isInvalidDecl() &&
1001        RequireCompleteType(Param->getLocation(), Param->getType(),
1002                               diag::err_typecheck_decl_incomplete_type)) {
1003      Param->setInvalidDecl();
1004      HasInvalidParm = true;
1005    }
1006
1007    // C99 6.9.1p5: If the declarator includes a parameter type list, the
1008    // declaration of each parameter shall include an identifier.
1009    if (Param->getIdentifier() == 0 &&
1010        !Param->isImplicit() &&
1011        !getLangOptions().CPlusPlus)
1012      Diag(Param->getLocation(), diag::err_parameter_name_omitted);
1013  }
1014
1015  return HasInvalidParm;
1016}
1017
1018/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1019/// no declarator (e.g. "struct foo;") is parsed.
1020Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
1021  // FIXME: Error on auto/register at file scope
1022  // FIXME: Error on inline/virtual/explicit
1023  // FIXME: Error on invalid restrict
1024  // FIXME: Warn on useless __thread
1025  // FIXME: Warn on useless const/volatile
1026  // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1027  // FIXME: Warn on useless attributes
1028  TagDecl *Tag = 0;
1029  if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1030      DS.getTypeSpecType() == DeclSpec::TST_struct ||
1031      DS.getTypeSpecType() == DeclSpec::TST_union ||
1032      DS.getTypeSpecType() == DeclSpec::TST_enum) {
1033    if (!DS.getTypeRep()) // We probably had an error
1034      return DeclPtrTy();
1035
1036    Tag = dyn_cast<TagDecl>(static_cast<Decl *>(DS.getTypeRep()));
1037  }
1038
1039  if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
1040    if (!Record->getDeclName() && Record->isDefinition() &&
1041        DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1042      if (getLangOptions().CPlusPlus ||
1043          Record->getDeclContext()->isRecord())
1044        return BuildAnonymousStructOrUnion(S, DS, Record);
1045
1046      Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1047        << DS.getSourceRange();
1048    }
1049
1050    // Microsoft allows unnamed struct/union fields. Don't complain
1051    // about them.
1052    // FIXME: Should we support Microsoft's extensions in this area?
1053    if (Record->getDeclName() && getLangOptions().Microsoft)
1054      return DeclPtrTy::make(Tag);
1055  }
1056
1057  if (!DS.isMissingDeclaratorOk() &&
1058      DS.getTypeSpecType() != DeclSpec::TST_error) {
1059    // Warn about typedefs of enums without names, since this is an
1060    // extension in both Microsoft an GNU.
1061    if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1062        Tag && isa<EnumDecl>(Tag)) {
1063      Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
1064        << DS.getSourceRange();
1065      return DeclPtrTy::make(Tag);
1066    }
1067
1068    Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1069      << DS.getSourceRange();
1070    return DeclPtrTy();
1071  }
1072
1073  return DeclPtrTy::make(Tag);
1074}
1075
1076/// InjectAnonymousStructOrUnionMembers - Inject the members of the
1077/// anonymous struct or union AnonRecord into the owning context Owner
1078/// and scope S. This routine will be invoked just after we realize
1079/// that an unnamed union or struct is actually an anonymous union or
1080/// struct, e.g.,
1081///
1082/// @code
1083/// union {
1084///   int i;
1085///   float f;
1086/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1087///    // f into the surrounding scope.x
1088/// @endcode
1089///
1090/// This routine is recursive, injecting the names of nested anonymous
1091/// structs/unions into the owning context and scope as well.
1092bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1093                                               RecordDecl *AnonRecord) {
1094  bool Invalid = false;
1095  for (RecordDecl::field_iterator F = AnonRecord->field_begin(Context),
1096                               FEnd = AnonRecord->field_end(Context);
1097       F != FEnd; ++F) {
1098    if ((*F)->getDeclName()) {
1099      NamedDecl *PrevDecl = LookupQualifiedName(Owner, (*F)->getDeclName(),
1100                                                LookupOrdinaryName, true);
1101      if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
1102        // C++ [class.union]p2:
1103        //   The names of the members of an anonymous union shall be
1104        //   distinct from the names of any other entity in the
1105        //   scope in which the anonymous union is declared.
1106        unsigned diagKind
1107          = AnonRecord->isUnion()? diag::err_anonymous_union_member_redecl
1108                                 : diag::err_anonymous_struct_member_redecl;
1109        Diag((*F)->getLocation(), diagKind)
1110          << (*F)->getDeclName();
1111        Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
1112        Invalid = true;
1113      } else {
1114        // C++ [class.union]p2:
1115        //   For the purpose of name lookup, after the anonymous union
1116        //   definition, the members of the anonymous union are
1117        //   considered to have been defined in the scope in which the
1118        //   anonymous union is declared.
1119        Owner->makeDeclVisibleInContext(Context, *F);
1120        S->AddDecl(DeclPtrTy::make(*F));
1121        IdResolver.AddDecl(*F);
1122      }
1123    } else if (const RecordType *InnerRecordType
1124                 = (*F)->getType()->getAsRecordType()) {
1125      RecordDecl *InnerRecord = InnerRecordType->getDecl();
1126      if (InnerRecord->isAnonymousStructOrUnion())
1127        Invalid = Invalid ||
1128          InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1129    }
1130  }
1131
1132  return Invalid;
1133}
1134
1135/// ActOnAnonymousStructOrUnion - Handle the declaration of an
1136/// anonymous structure or union. Anonymous unions are a C++ feature
1137/// (C++ [class.union]) and a GNU C extension; anonymous structures
1138/// are a GNU C and GNU C++ extension.
1139Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1140                                                  RecordDecl *Record) {
1141  DeclContext *Owner = Record->getDeclContext();
1142
1143  // Diagnose whether this anonymous struct/union is an extension.
1144  if (Record->isUnion() && !getLangOptions().CPlusPlus)
1145    Diag(Record->getLocation(), diag::ext_anonymous_union);
1146  else if (!Record->isUnion())
1147    Diag(Record->getLocation(), diag::ext_anonymous_struct);
1148
1149  // C and C++ require different kinds of checks for anonymous
1150  // structs/unions.
1151  bool Invalid = false;
1152  if (getLangOptions().CPlusPlus) {
1153    const char* PrevSpec = 0;
1154    // C++ [class.union]p3:
1155    //   Anonymous unions declared in a named namespace or in the
1156    //   global namespace shall be declared static.
1157    if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1158        (isa<TranslationUnitDecl>(Owner) ||
1159         (isa<NamespaceDecl>(Owner) &&
1160          cast<NamespaceDecl>(Owner)->getDeclName()))) {
1161      Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1162      Invalid = true;
1163
1164      // Recover by adding 'static'.
1165      DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(), PrevSpec);
1166    }
1167    // C++ [class.union]p3:
1168    //   A storage class is not allowed in a declaration of an
1169    //   anonymous union in a class scope.
1170    else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1171             isa<RecordDecl>(Owner)) {
1172      Diag(DS.getStorageClassSpecLoc(),
1173           diag::err_anonymous_union_with_storage_spec);
1174      Invalid = true;
1175
1176      // Recover by removing the storage specifier.
1177      DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
1178                             PrevSpec);
1179    }
1180
1181    // C++ [class.union]p2:
1182    //   The member-specification of an anonymous union shall only
1183    //   define non-static data members. [Note: nested types and
1184    //   functions cannot be declared within an anonymous union. ]
1185    for (DeclContext::decl_iterator Mem = Record->decls_begin(Context),
1186                                 MemEnd = Record->decls_end(Context);
1187         Mem != MemEnd; ++Mem) {
1188      if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1189        // C++ [class.union]p3:
1190        //   An anonymous union shall not have private or protected
1191        //   members (clause 11).
1192        if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1193          Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1194            << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1195          Invalid = true;
1196        }
1197      } else if ((*Mem)->isImplicit()) {
1198        // Any implicit members are fine.
1199      } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1200        // This is a type that showed up in an
1201        // elaborated-type-specifier inside the anonymous struct or
1202        // union, but which actually declares a type outside of the
1203        // anonymous struct or union. It's okay.
1204      } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1205        if (!MemRecord->isAnonymousStructOrUnion() &&
1206            MemRecord->getDeclName()) {
1207          // This is a nested type declaration.
1208          Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1209            << (int)Record->isUnion();
1210          Invalid = true;
1211        }
1212      } else {
1213        // We have something that isn't a non-static data
1214        // member. Complain about it.
1215        unsigned DK = diag::err_anonymous_record_bad_member;
1216        if (isa<TypeDecl>(*Mem))
1217          DK = diag::err_anonymous_record_with_type;
1218        else if (isa<FunctionDecl>(*Mem))
1219          DK = diag::err_anonymous_record_with_function;
1220        else if (isa<VarDecl>(*Mem))
1221          DK = diag::err_anonymous_record_with_static;
1222        Diag((*Mem)->getLocation(), DK)
1223            << (int)Record->isUnion();
1224          Invalid = true;
1225      }
1226    }
1227  }
1228
1229  if (!Record->isUnion() && !Owner->isRecord()) {
1230    Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1231      << (int)getLangOptions().CPlusPlus;
1232    Invalid = true;
1233  }
1234
1235  // Create a declaration for this anonymous struct/union.
1236  NamedDecl *Anon = 0;
1237  if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1238    Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
1239                             /*IdentifierInfo=*/0,
1240                             Context.getTypeDeclType(Record),
1241                             /*BitWidth=*/0, /*Mutable=*/false);
1242    Anon->setAccess(AS_public);
1243    if (getLangOptions().CPlusPlus)
1244      FieldCollector->Add(cast<FieldDecl>(Anon));
1245  } else {
1246    VarDecl::StorageClass SC;
1247    switch (DS.getStorageClassSpec()) {
1248    default: assert(0 && "Unknown storage class!");
1249    case DeclSpec::SCS_unspecified:    SC = VarDecl::None; break;
1250    case DeclSpec::SCS_extern:         SC = VarDecl::Extern; break;
1251    case DeclSpec::SCS_static:         SC = VarDecl::Static; break;
1252    case DeclSpec::SCS_auto:           SC = VarDecl::Auto; break;
1253    case DeclSpec::SCS_register:       SC = VarDecl::Register; break;
1254    case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1255    case DeclSpec::SCS_mutable:
1256      // mutable can only appear on non-static class members, so it's always
1257      // an error here
1258      Diag(Record->getLocation(), diag::err_mutable_nonmember);
1259      Invalid = true;
1260      SC = VarDecl::None;
1261      break;
1262    }
1263
1264    Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
1265                           /*IdentifierInfo=*/0,
1266                           Context.getTypeDeclType(Record),
1267                           SC, DS.getSourceRange().getBegin());
1268  }
1269  Anon->setImplicit();
1270
1271  // Add the anonymous struct/union object to the current
1272  // context. We'll be referencing this object when we refer to one of
1273  // its members.
1274  Owner->addDecl(Context, Anon);
1275
1276  // Inject the members of the anonymous struct/union into the owning
1277  // context and into the identifier resolver chain for name lookup
1278  // purposes.
1279  if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1280    Invalid = true;
1281
1282  // Mark this as an anonymous struct/union type. Note that we do not
1283  // do this until after we have already checked and injected the
1284  // members of this anonymous struct/union type, because otherwise
1285  // the members could be injected twice: once by DeclContext when it
1286  // builds its lookup table, and once by
1287  // InjectAnonymousStructOrUnionMembers.
1288  Record->setAnonymousStructOrUnion(true);
1289
1290  if (Invalid)
1291    Anon->setInvalidDecl();
1292
1293  return DeclPtrTy::make(Anon);
1294}
1295
1296
1297/// GetNameForDeclarator - Determine the full declaration name for the
1298/// given Declarator.
1299DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
1300  switch (D.getKind()) {
1301  case Declarator::DK_Abstract:
1302    assert(D.getIdentifier() == 0 && "abstract declarators have no name");
1303    return DeclarationName();
1304
1305  case Declarator::DK_Normal:
1306    assert (D.getIdentifier() != 0 && "normal declarators have an identifier");
1307    return DeclarationName(D.getIdentifier());
1308
1309  case Declarator::DK_Constructor: {
1310    QualType Ty = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1311    Ty = Context.getCanonicalType(Ty);
1312    return Context.DeclarationNames.getCXXConstructorName(Ty);
1313  }
1314
1315  case Declarator::DK_Destructor: {
1316    QualType Ty = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1317    Ty = Context.getCanonicalType(Ty);
1318    return Context.DeclarationNames.getCXXDestructorName(Ty);
1319  }
1320
1321  case Declarator::DK_Conversion: {
1322    // FIXME: We'd like to keep the non-canonical type for diagnostics!
1323    QualType Ty = QualType::getFromOpaquePtr(D.getDeclaratorIdType());
1324    Ty = Context.getCanonicalType(Ty);
1325    return Context.DeclarationNames.getCXXConversionFunctionName(Ty);
1326  }
1327
1328  case Declarator::DK_Operator:
1329    assert(D.getIdentifier() == 0 && "operator names have no identifier");
1330    return Context.DeclarationNames.getCXXOperatorName(
1331                                                D.getOverloadedOperator());
1332  }
1333
1334  assert(false && "Unknown name kind");
1335  return DeclarationName();
1336}
1337
1338/// isNearlyMatchingFunction - Determine whether the C++ functions
1339/// Declaration and Definition are "nearly" matching. This heuristic
1340/// is used to improve diagnostics in the case where an out-of-line
1341/// function definition doesn't match any declaration within
1342/// the class or namespace.
1343static bool isNearlyMatchingFunction(ASTContext &Context,
1344                                     FunctionDecl *Declaration,
1345                                     FunctionDecl *Definition) {
1346  if (Declaration->param_size() != Definition->param_size())
1347    return false;
1348  for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1349    QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1350    QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1351
1352    DeclParamTy = Context.getCanonicalType(DeclParamTy.getNonReferenceType());
1353    DefParamTy = Context.getCanonicalType(DefParamTy.getNonReferenceType());
1354    if (DeclParamTy.getUnqualifiedType() != DefParamTy.getUnqualifiedType())
1355      return false;
1356  }
1357
1358  return true;
1359}
1360
1361Sema::DeclPtrTy
1362Sema::ActOnDeclarator(Scope *S, Declarator &D, bool IsFunctionDefinition) {
1363  DeclarationName Name = GetNameForDeclarator(D);
1364
1365  // All of these full declarators require an identifier.  If it doesn't have
1366  // one, the ParsedFreeStandingDeclSpec action should be used.
1367  if (!Name) {
1368    if (!D.isInvalidType())  // Reject this if we think it is valid.
1369      Diag(D.getDeclSpec().getSourceRange().getBegin(),
1370           diag::err_declarator_need_ident)
1371        << D.getDeclSpec().getSourceRange() << D.getSourceRange();
1372    return DeclPtrTy();
1373  }
1374
1375  // The scope passed in may not be a decl scope.  Zip up the scope tree until
1376  // we find one that is.
1377  while ((S->getFlags() & Scope::DeclScope) == 0 ||
1378         (S->getFlags() & Scope::TemplateParamScope) != 0)
1379    S = S->getParent();
1380
1381  DeclContext *DC;
1382  NamedDecl *PrevDecl;
1383  NamedDecl *New;
1384
1385  QualType R = GetTypeForDeclarator(D, S);
1386
1387  // See if this is a redefinition of a variable in the same scope.
1388  if (D.getCXXScopeSpec().isInvalid()) {
1389    DC = CurContext;
1390    PrevDecl = 0;
1391    D.setInvalidType();
1392  } else if (!D.getCXXScopeSpec().isSet()) {
1393    LookupNameKind NameKind = LookupOrdinaryName;
1394
1395    // If the declaration we're planning to build will be a function
1396    // or object with linkage, then look for another declaration with
1397    // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1398    if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1399      /* Do nothing*/;
1400    else if (R->isFunctionType()) {
1401      if (CurContext->isFunctionOrMethod())
1402        NameKind = LookupRedeclarationWithLinkage;
1403    } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
1404      NameKind = LookupRedeclarationWithLinkage;
1405
1406    DC = CurContext;
1407    PrevDecl = LookupName(S, Name, NameKind, true,
1408                          D.getDeclSpec().getStorageClassSpec() !=
1409                            DeclSpec::SCS_static,
1410                          D.getIdentifierLoc());
1411  } else { // Something like "int foo::x;"
1412    DC = computeDeclContext(D.getCXXScopeSpec());
1413    // FIXME: RequireCompleteDeclContext(D.getCXXScopeSpec()); ?
1414    PrevDecl = LookupQualifiedName(DC, Name, LookupOrdinaryName, true);
1415
1416    // C++ 7.3.1.2p2:
1417    // Members (including explicit specializations of templates) of a named
1418    // namespace can also be defined outside that namespace by explicit
1419    // qualification of the name being defined, provided that the entity being
1420    // defined was already declared in the namespace and the definition appears
1421    // after the point of declaration in a namespace that encloses the
1422    // declarations namespace.
1423    //
1424    // Note that we only check the context at this point. We don't yet
1425    // have enough information to make sure that PrevDecl is actually
1426    // the declaration we want to match. For example, given:
1427    //
1428    //   class X {
1429    //     void f();
1430    //     void f(float);
1431    //   };
1432    //
1433    //   void X::f(int) { } // ill-formed
1434    //
1435    // In this case, PrevDecl will point to the overload set
1436    // containing the two f's declared in X, but neither of them
1437    // matches.
1438
1439    // First check whether we named the global scope.
1440    if (isa<TranslationUnitDecl>(DC)) {
1441      Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
1442        << Name << D.getCXXScopeSpec().getRange();
1443    } else if (!CurContext->Encloses(DC)) {
1444      // The qualifying scope doesn't enclose the original declaration.
1445      // Emit diagnostic based on current scope.
1446      SourceLocation L = D.getIdentifierLoc();
1447      SourceRange R = D.getCXXScopeSpec().getRange();
1448      if (isa<FunctionDecl>(CurContext))
1449        Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1450      else
1451        Diag(L, diag::err_invalid_declarator_scope)
1452          << Name << cast<NamedDecl>(DC) << R;
1453      D.setInvalidType();
1454    }
1455  }
1456
1457  if (PrevDecl && PrevDecl->isTemplateParameter()) {
1458    // Maybe we will complain about the shadowed template parameter.
1459    if (!D.isInvalidType())
1460      if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl))
1461        D.setInvalidType();
1462
1463    // Just pretend that we didn't see the previous declaration.
1464    PrevDecl = 0;
1465  }
1466
1467  // In C++, the previous declaration we find might be a tag type
1468  // (class or enum). In this case, the new declaration will hide the
1469  // tag type. Note that this does does not apply if we're declaring a
1470  // typedef (C++ [dcl.typedef]p4).
1471  if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag &&
1472      D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
1473    PrevDecl = 0;
1474
1475  bool Redeclaration = false;
1476  if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
1477    New = ActOnTypedefDeclarator(S, D, DC, R, PrevDecl, Redeclaration);
1478  } else if (R->isFunctionType()) {
1479    New = ActOnFunctionDeclarator(S, D, DC, R, PrevDecl,
1480                                  IsFunctionDefinition, Redeclaration);
1481  } else {
1482    New = ActOnVariableDeclarator(S, D, DC, R, PrevDecl, Redeclaration);
1483  }
1484
1485  if (New == 0)
1486    return DeclPtrTy();
1487
1488  // If this has an identifier and is not an invalid redeclaration,
1489  // add it to the scope stack.
1490  if (Name && !(Redeclaration && New->isInvalidDecl()))
1491    PushOnScopeChains(New, S);
1492
1493  return DeclPtrTy::make(New);
1494}
1495
1496/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
1497/// types into constant array types in certain situations which would otherwise
1498/// be errors (for GCC compatibility).
1499static QualType TryToFixInvalidVariablyModifiedType(QualType T,
1500                                                    ASTContext &Context,
1501                                                    bool &SizeIsNegative) {
1502  // This method tries to turn a variable array into a constant
1503  // array even when the size isn't an ICE.  This is necessary
1504  // for compatibility with code that depends on gcc's buggy
1505  // constant expression folding, like struct {char x[(int)(char*)2];}
1506  SizeIsNegative = false;
1507
1508  if (const PointerType* PTy = dyn_cast<PointerType>(T)) {
1509    QualType Pointee = PTy->getPointeeType();
1510    QualType FixedType =
1511        TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
1512    if (FixedType.isNull()) return FixedType;
1513    FixedType = Context.getPointerType(FixedType);
1514    FixedType.setCVRQualifiers(T.getCVRQualifiers());
1515    return FixedType;
1516  }
1517
1518  const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
1519  if (!VLATy)
1520    return QualType();
1521  // FIXME: We should probably handle this case
1522  if (VLATy->getElementType()->isVariablyModifiedType())
1523    return QualType();
1524
1525  Expr::EvalResult EvalResult;
1526  if (!VLATy->getSizeExpr() ||
1527      !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
1528      !EvalResult.Val.isInt())
1529    return QualType();
1530
1531  llvm::APSInt &Res = EvalResult.Val.getInt();
1532  if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned()))
1533    return Context.getConstantArrayType(VLATy->getElementType(),
1534                                        Res, ArrayType::Normal, 0);
1535
1536  SizeIsNegative = true;
1537  return QualType();
1538}
1539
1540/// \brief Register the given locally-scoped external C declaration so
1541/// that it can be found later for redeclarations
1542void
1543Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
1544                                       Scope *S) {
1545  assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
1546         "Decl is not a locally-scoped decl!");
1547  // Note that we have a locally-scoped external with this name.
1548  LocallyScopedExternalDecls[ND->getDeclName()] = ND;
1549
1550  if (!PrevDecl)
1551    return;
1552
1553  // If there was a previous declaration of this variable, it may be
1554  // in our identifier chain. Update the identifier chain with the new
1555  // declaration.
1556  if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
1557    // The previous declaration was found on the identifer resolver
1558    // chain, so remove it from its scope.
1559    while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
1560      S = S->getParent();
1561
1562    if (S)
1563      S->RemoveDecl(DeclPtrTy::make(PrevDecl));
1564  }
1565}
1566
1567/// \brief Diagnose function specifiers on a declaration of an identifier that
1568/// does not identify a function.
1569void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
1570  // FIXME: We should probably indicate the identifier in question to avoid
1571  // confusion for constructs like "inline int a(), b;"
1572  if (D.getDeclSpec().isInlineSpecified())
1573    Diag(D.getDeclSpec().getInlineSpecLoc(),
1574         diag::err_inline_non_function);
1575
1576  if (D.getDeclSpec().isVirtualSpecified())
1577    Diag(D.getDeclSpec().getVirtualSpecLoc(),
1578         diag::err_virtual_non_function);
1579
1580  if (D.getDeclSpec().isExplicitSpecified())
1581    Diag(D.getDeclSpec().getExplicitSpecLoc(),
1582         diag::err_explicit_non_function);
1583}
1584
1585NamedDecl*
1586Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1587                             QualType R, Decl* PrevDecl, bool &Redeclaration) {
1588  // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
1589  if (D.getCXXScopeSpec().isSet()) {
1590    Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
1591      << D.getCXXScopeSpec().getRange();
1592    D.setInvalidType();
1593    // Pretend we didn't see the scope specifier.
1594    DC = 0;
1595  }
1596
1597  if (getLangOptions().CPlusPlus) {
1598    // Check that there are no default arguments (C++ only).
1599    CheckExtraCXXDefaultArguments(D);
1600  }
1601
1602  DiagnoseFunctionSpecifiers(D);
1603
1604  if (D.getDeclSpec().isThreadSpecified())
1605    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
1606
1607  TypedefDecl *NewTD = ParseTypedefDecl(S, D, R);
1608  if (!NewTD) return 0;
1609
1610  if (D.isInvalidType())
1611    NewTD->setInvalidDecl();
1612
1613  // Handle attributes prior to checking for duplicates in MergeVarDecl
1614  ProcessDeclAttributes(NewTD, D);
1615  // Merge the decl with the existing one if appropriate. If the decl is
1616  // in an outer scope, it isn't the same thing.
1617  if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
1618    Redeclaration = true;
1619    MergeTypeDefDecl(NewTD, PrevDecl);
1620  }
1621
1622  // C99 6.7.7p2: If a typedef name specifies a variably modified type
1623  // then it shall have block scope.
1624  QualType T = NewTD->getUnderlyingType();
1625  if (T->isVariablyModifiedType()) {
1626    CurFunctionNeedsScopeChecking = true;
1627
1628    if (S->getFnParent() == 0) {
1629      bool SizeIsNegative;
1630      QualType FixedTy =
1631          TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
1632      if (!FixedTy.isNull()) {
1633        Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
1634        NewTD->setUnderlyingType(FixedTy);
1635      } else {
1636        if (SizeIsNegative)
1637          Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
1638        else if (T->isVariableArrayType())
1639          Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
1640        else
1641          Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
1642        NewTD->setInvalidDecl();
1643      }
1644    }
1645  }
1646  return NewTD;
1647}
1648
1649/// \brief Determines whether the given declaration is an out-of-scope
1650/// previous declaration.
1651///
1652/// This routine should be invoked when name lookup has found a
1653/// previous declaration (PrevDecl) that is not in the scope where a
1654/// new declaration by the same name is being introduced. If the new
1655/// declaration occurs in a local scope, previous declarations with
1656/// linkage may still be considered previous declarations (C99
1657/// 6.2.2p4-5, C++ [basic.link]p6).
1658///
1659/// \param PrevDecl the previous declaration found by name
1660/// lookup
1661///
1662/// \param DC the context in which the new declaration is being
1663/// declared.
1664///
1665/// \returns true if PrevDecl is an out-of-scope previous declaration
1666/// for a new delcaration with the same name.
1667static bool
1668isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
1669                                ASTContext &Context) {
1670  if (!PrevDecl)
1671    return 0;
1672
1673  // FIXME: PrevDecl could be an OverloadedFunctionDecl, in which
1674  // case we need to check each of the overloaded functions.
1675  if (!PrevDecl->hasLinkage())
1676    return false;
1677
1678  if (Context.getLangOptions().CPlusPlus) {
1679    // C++ [basic.link]p6:
1680    //   If there is a visible declaration of an entity with linkage
1681    //   having the same name and type, ignoring entities declared
1682    //   outside the innermost enclosing namespace scope, the block
1683    //   scope declaration declares that same entity and receives the
1684    //   linkage of the previous declaration.
1685    DeclContext *OuterContext = DC->getLookupContext();
1686    if (!OuterContext->isFunctionOrMethod())
1687      // This rule only applies to block-scope declarations.
1688      return false;
1689    else {
1690      DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
1691      if (PrevOuterContext->isRecord())
1692        // We found a member function: ignore it.
1693        return false;
1694      else {
1695        // Find the innermost enclosing namespace for the new and
1696        // previous declarations.
1697        while (!OuterContext->isFileContext())
1698          OuterContext = OuterContext->getParent();
1699        while (!PrevOuterContext->isFileContext())
1700          PrevOuterContext = PrevOuterContext->getParent();
1701
1702        // The previous declaration is in a different namespace, so it
1703        // isn't the same function.
1704        if (OuterContext->getPrimaryContext() !=
1705            PrevOuterContext->getPrimaryContext())
1706          return false;
1707      }
1708    }
1709  }
1710
1711  return true;
1712}
1713
1714NamedDecl*
1715Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1716                              QualType R,NamedDecl* PrevDecl,
1717                              bool &Redeclaration) {
1718  DeclarationName Name = GetNameForDeclarator(D);
1719
1720  // Check that there are no default arguments (C++ only).
1721  if (getLangOptions().CPlusPlus)
1722    CheckExtraCXXDefaultArguments(D);
1723
1724  VarDecl *NewVD;
1725  VarDecl::StorageClass SC;
1726  switch (D.getDeclSpec().getStorageClassSpec()) {
1727  default: assert(0 && "Unknown storage class!");
1728  case DeclSpec::SCS_unspecified:    SC = VarDecl::None; break;
1729  case DeclSpec::SCS_extern:         SC = VarDecl::Extern; break;
1730  case DeclSpec::SCS_static:         SC = VarDecl::Static; break;
1731  case DeclSpec::SCS_auto:           SC = VarDecl::Auto; break;
1732  case DeclSpec::SCS_register:       SC = VarDecl::Register; break;
1733  case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1734  case DeclSpec::SCS_mutable:
1735    // mutable can only appear on non-static class members, so it's always
1736    // an error here
1737    Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
1738    D.setInvalidType();
1739    SC = VarDecl::None;
1740    break;
1741  }
1742
1743  IdentifierInfo *II = Name.getAsIdentifierInfo();
1744  if (!II) {
1745    Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
1746      << Name.getAsString();
1747    return 0;
1748  }
1749
1750  DiagnoseFunctionSpecifiers(D);
1751
1752  if (!DC->isRecord() && S->getFnParent() == 0) {
1753    // C99 6.9p2: The storage-class specifiers auto and register shall not
1754    // appear in the declaration specifiers in an external declaration.
1755    if (SC == VarDecl::Auto || SC == VarDecl::Register) {
1756
1757      // If this is a register variable with an asm label specified, then this
1758      // is a GNU extension.
1759      if (SC == VarDecl::Register && D.getAsmLabel())
1760        Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
1761      else
1762        Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
1763      D.setInvalidType();
1764    }
1765  }
1766  if (DC->isRecord() && !CurContext->isRecord()) {
1767    // This is an out-of-line definition of a static data member.
1768    if (SC == VarDecl::Static) {
1769      Diag(D.getDeclSpec().getStorageClassSpecLoc(),
1770           diag::err_static_out_of_line)
1771        << CodeModificationHint::CreateRemoval(
1772                       SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
1773    } else if (SC == VarDecl::None)
1774      SC = VarDecl::Static;
1775  }
1776
1777  // The variable can not
1778  NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
1779                          II, R, SC,
1780                          // FIXME: Move to DeclGroup...
1781                          D.getDeclSpec().getSourceRange().getBegin());
1782
1783  if (D.isInvalidType())
1784    NewVD->setInvalidDecl();
1785
1786  if (D.getDeclSpec().isThreadSpecified()) {
1787    if (NewVD->hasLocalStorage())
1788      Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
1789    else if (!Context.Target.isTLSSupported())
1790      Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
1791    else
1792      NewVD->setThreadSpecified(true);
1793  }
1794
1795  // Set the lexical context. If the declarator has a C++ scope specifier, the
1796  // lexical context will be different from the semantic context.
1797  NewVD->setLexicalDeclContext(CurContext);
1798
1799  // Handle attributes prior to checking for duplicates in MergeVarDecl
1800  ProcessDeclAttributes(NewVD, D);
1801
1802  // Handle GNU asm-label extension (encoded as an attribute).
1803  if (Expr *E = (Expr*) D.getAsmLabel()) {
1804    // The parser guarantees this is a string.
1805    StringLiteral *SE = cast<StringLiteral>(E);
1806    NewVD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
1807                                                        SE->getByteLength())));
1808  }
1809
1810  // If name lookup finds a previous declaration that is not in the
1811  // same scope as the new declaration, this may still be an
1812  // acceptable redeclaration.
1813  if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
1814      !(NewVD->hasLinkage() &&
1815        isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
1816    PrevDecl = 0;
1817
1818  // Merge the decl with the existing one if appropriate.
1819  if (PrevDecl) {
1820    if (isa<FieldDecl>(PrevDecl) && D.getCXXScopeSpec().isSet()) {
1821      // The user tried to define a non-static data member
1822      // out-of-line (C++ [dcl.meaning]p1).
1823      Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
1824        << D.getCXXScopeSpec().getRange();
1825      PrevDecl = 0;
1826      NewVD->setInvalidDecl();
1827    }
1828  } else if (D.getCXXScopeSpec().isSet()) {
1829    // No previous declaration in the qualifying scope.
1830    Diag(D.getIdentifierLoc(), diag::err_typecheck_no_member)
1831      << Name << D.getCXXScopeSpec().getRange();
1832    NewVD->setInvalidDecl();
1833  }
1834
1835  CheckVariableDeclaration(NewVD, PrevDecl, Redeclaration);
1836
1837  // If this is a locally-scoped extern C variable, update the map of
1838  // such variables.
1839  if (CurContext->isFunctionOrMethod() && NewVD->isExternC(Context) &&
1840      !NewVD->isInvalidDecl())
1841    RegisterLocallyScopedExternCDecl(NewVD, PrevDecl, S);
1842
1843  return NewVD;
1844}
1845
1846/// \brief Perform semantic checking on a newly-created variable
1847/// declaration.
1848///
1849/// This routine performs all of the type-checking required for a
1850/// variable declaration once it has been built. It is used both to
1851/// check variables after they have been parsed and their declarators
1852/// have been translated into a declaration, and to check variables
1853/// that have been instantiated from a template.
1854///
1855/// Sets NewVD->isInvalidDecl() if an error was encountered.
1856void Sema::CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
1857                                    bool &Redeclaration) {
1858  // If the decl is already known invalid, don't check it.
1859  if (NewVD->isInvalidDecl())
1860    return;
1861
1862  QualType T = NewVD->getType();
1863
1864  if (T->isObjCInterfaceType()) {
1865    Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
1866    return NewVD->setInvalidDecl();
1867  }
1868
1869  // The variable can not have an abstract class type.
1870  if (RequireNonAbstractType(NewVD->getLocation(), T,
1871                             diag::err_abstract_type_in_decl,
1872                             AbstractVariableType))
1873    return NewVD->setInvalidDecl();
1874
1875  // Emit an error if an address space was applied to decl with local storage.
1876  // This includes arrays of objects with address space qualifiers, but not
1877  // automatic variables that point to other address spaces.
1878  // ISO/IEC TR 18037 S5.1.2
1879  if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
1880    Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
1881    return NewVD->setInvalidDecl();
1882  }
1883
1884  if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
1885      && !NewVD->hasAttr<BlocksAttr>())
1886    Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
1887
1888  bool isVM = T->isVariablyModifiedType();
1889  if (isVM || NewVD->hasAttr<CleanupAttr>())
1890    CurFunctionNeedsScopeChecking = true;
1891
1892  if ((isVM && NewVD->hasLinkage()) ||
1893      (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
1894    bool SizeIsNegative;
1895    QualType FixedTy =
1896        TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
1897
1898    if (FixedTy.isNull() && T->isVariableArrayType()) {
1899      const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
1900      // FIXME: This won't give the correct result for
1901      // int a[10][n];
1902      SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
1903
1904      if (NewVD->isFileVarDecl())
1905        Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
1906        << SizeRange;
1907      else if (NewVD->getStorageClass() == VarDecl::Static)
1908        Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
1909        << SizeRange;
1910      else
1911        Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
1912        << SizeRange;
1913      return NewVD->setInvalidDecl();
1914    }
1915
1916    if (FixedTy.isNull()) {
1917      if (NewVD->isFileVarDecl())
1918        Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
1919      else
1920        Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
1921      return NewVD->setInvalidDecl();
1922    }
1923
1924    Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
1925    NewVD->setType(FixedTy);
1926  }
1927
1928  if (!PrevDecl && NewVD->isExternC(Context)) {
1929    // Since we did not find anything by this name and we're declaring
1930    // an extern "C" variable, look for a non-visible extern "C"
1931    // declaration with the same name.
1932    llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
1933      = LocallyScopedExternalDecls.find(NewVD->getDeclName());
1934    if (Pos != LocallyScopedExternalDecls.end())
1935      PrevDecl = Pos->second;
1936  }
1937
1938  if (T->isVoidType() && !NewVD->hasExternalStorage()) {
1939    Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
1940      << T;
1941    return NewVD->setInvalidDecl();
1942  }
1943
1944  if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
1945    Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
1946    return NewVD->setInvalidDecl();
1947  }
1948
1949  if (isVM && NewVD->hasAttr<BlocksAttr>()) {
1950    Diag(NewVD->getLocation(), diag::err_block_on_vm);
1951    return NewVD->setInvalidDecl();
1952  }
1953
1954  if (PrevDecl) {
1955    Redeclaration = true;
1956    MergeVarDecl(NewVD, PrevDecl);
1957  }
1958}
1959
1960NamedDecl*
1961Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1962                              QualType R, NamedDecl* PrevDecl,
1963                              bool IsFunctionDefinition, bool &Redeclaration) {
1964  assert(R.getTypePtr()->isFunctionType());
1965
1966  DeclarationName Name = GetNameForDeclarator(D);
1967  FunctionDecl::StorageClass SC = FunctionDecl::None;
1968  switch (D.getDeclSpec().getStorageClassSpec()) {
1969  default: assert(0 && "Unknown storage class!");
1970  case DeclSpec::SCS_auto:
1971  case DeclSpec::SCS_register:
1972  case DeclSpec::SCS_mutable:
1973    Diag(D.getDeclSpec().getStorageClassSpecLoc(),
1974         diag::err_typecheck_sclass_func);
1975    D.setInvalidType();
1976    break;
1977  case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
1978  case DeclSpec::SCS_extern:      SC = FunctionDecl::Extern; break;
1979  case DeclSpec::SCS_static: {
1980    if (CurContext->getLookupContext()->isFunctionOrMethod()) {
1981      // C99 6.7.1p5:
1982      //   The declaration of an identifier for a function that has
1983      //   block scope shall have no explicit storage-class specifier
1984      //   other than extern
1985      // See also (C++ [dcl.stc]p4).
1986      Diag(D.getDeclSpec().getStorageClassSpecLoc(),
1987           diag::err_static_block_func);
1988      SC = FunctionDecl::None;
1989    } else
1990      SC = FunctionDecl::Static;
1991    break;
1992  }
1993  case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
1994  }
1995
1996  if (D.getDeclSpec().isThreadSpecified())
1997    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
1998
1999  bool isInline = D.getDeclSpec().isInlineSpecified();
2000  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2001  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2002
2003  // Check that the return type is not an abstract class type.
2004  // For record types, this is done by the AbstractClassUsageDiagnoser once
2005  // the class has been completely parsed.
2006  if (!DC->isRecord() &&
2007      RequireNonAbstractType(D.getIdentifierLoc(),
2008                             R->getAsFunctionType()->getResultType(),
2009                             diag::err_abstract_type_in_decl,
2010                             AbstractReturnType))
2011    D.setInvalidType();
2012
2013  // Do not allow returning a objc interface by-value.
2014  if (R->getAsFunctionType()->getResultType()->isObjCInterfaceType()) {
2015    Diag(D.getIdentifierLoc(),
2016         diag::err_object_cannot_be_passed_returned_by_value) << 0
2017      << R->getAsFunctionType()->getResultType();
2018    D.setInvalidType();
2019  }
2020
2021  bool isVirtualOkay = false;
2022  FunctionDecl *NewFD;
2023  if (D.getKind() == Declarator::DK_Constructor) {
2024    // This is a C++ constructor declaration.
2025    assert(DC->isRecord() &&
2026           "Constructors can only be declared in a member context");
2027
2028    R = CheckConstructorDeclarator(D, R, SC);
2029
2030    // Create the new declaration
2031    NewFD = CXXConstructorDecl::Create(Context,
2032                                       cast<CXXRecordDecl>(DC),
2033                                       D.getIdentifierLoc(), Name, R,
2034                                       isExplicit, isInline,
2035                                       /*isImplicitlyDeclared=*/false);
2036  } else if (D.getKind() == Declarator::DK_Destructor) {
2037    // This is a C++ destructor declaration.
2038    if (DC->isRecord()) {
2039      R = CheckDestructorDeclarator(D, SC);
2040
2041      NewFD = CXXDestructorDecl::Create(Context,
2042                                        cast<CXXRecordDecl>(DC),
2043                                        D.getIdentifierLoc(), Name, R,
2044                                        isInline,
2045                                        /*isImplicitlyDeclared=*/false);
2046
2047      isVirtualOkay = true;
2048    } else {
2049      Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2050
2051      // Create a FunctionDecl to satisfy the function definition parsing
2052      // code path.
2053      NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
2054                                   Name, R, SC, isInline,
2055                                   /*hasPrototype=*/true,
2056                                   // FIXME: Move to DeclGroup...
2057                                   D.getDeclSpec().getSourceRange().getBegin());
2058      D.setInvalidType();
2059    }
2060  } else if (D.getKind() == Declarator::DK_Conversion) {
2061    if (!DC->isRecord()) {
2062      Diag(D.getIdentifierLoc(),
2063           diag::err_conv_function_not_member);
2064      return 0;
2065    }
2066
2067    CheckConversionDeclarator(D, R, SC);
2068    NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
2069                                      D.getIdentifierLoc(), Name, R,
2070                                      isInline, isExplicit);
2071
2072    isVirtualOkay = true;
2073  } else if (DC->isRecord()) {
2074    // If the of the function is the same as the name of the record, then this
2075    // must be an invalid constructor that has a return type.
2076    // (The parser checks for a return type and makes the declarator a
2077    // constructor if it has no return type).
2078    // must have an invalid constructor that has a return type
2079    if (Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2080      Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2081        << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2082        << SourceRange(D.getIdentifierLoc());
2083      return 0;
2084    }
2085
2086    // This is a C++ method declaration.
2087    NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
2088                                  D.getIdentifierLoc(), Name, R,
2089                                  (SC == FunctionDecl::Static), isInline);
2090
2091    isVirtualOkay = (SC != FunctionDecl::Static);
2092  } else {
2093    // Determine whether the function was written with a
2094    // prototype. This true when:
2095    //   - we're in C++ (where every function has a prototype),
2096    //   - there is a prototype in the declarator, or
2097    //   - the type R of the function is some kind of typedef or other reference
2098    //     to a type name (which eventually refers to a function type).
2099    bool HasPrototype =
2100       getLangOptions().CPlusPlus ||
2101       (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
2102       (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
2103
2104    NewFD = FunctionDecl::Create(Context, DC,
2105                                 D.getIdentifierLoc(),
2106                                 Name, R, SC, isInline, HasPrototype,
2107                                 // FIXME: Move to DeclGroup...
2108                                 D.getDeclSpec().getSourceRange().getBegin());
2109  }
2110
2111  if (D.isInvalidType())
2112    NewFD->setInvalidDecl();
2113
2114  // Set the lexical context. If the declarator has a C++
2115  // scope specifier, the lexical context will be different
2116  // from the semantic context.
2117  NewFD->setLexicalDeclContext(CurContext);
2118
2119  // C++ [dcl.fct.spec]p5:
2120  //   The virtual specifier shall only be used in declarations of
2121  //   nonstatic class member functions that appear within a
2122  //   member-specification of a class declaration; see 10.3.
2123  //
2124  if (isVirtual && !NewFD->isInvalidDecl()) {
2125    if (!isVirtualOkay) {
2126       Diag(D.getDeclSpec().getVirtualSpecLoc(),
2127           diag::err_virtual_non_function);
2128    } else if (!CurContext->isRecord()) {
2129      // 'virtual' was specified outside of the class.
2130      Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2131        << CodeModificationHint::CreateRemoval(
2132                             SourceRange(D.getDeclSpec().getVirtualSpecLoc()));
2133    } else {
2134      // Okay: Add virtual to the method.
2135      cast<CXXMethodDecl>(NewFD)->setVirtualAsWritten(true);
2136      CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
2137      CurClass->setAggregate(false);
2138      CurClass->setPOD(false);
2139      CurClass->setPolymorphic(true);
2140      CurClass->setHasTrivialConstructor(false);
2141    }
2142  }
2143
2144  if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) {
2145    // Look for virtual methods in base classes that this method might override.
2146
2147    BasePaths Paths;
2148    // FIXME: This will not include hidden member functions.
2149    if (LookupInBases(cast<CXXRecordDecl>(DC),
2150                      MemberLookupCriteria(Name, LookupMemberName,
2151                                           // FIXME: Shouldn't IDNS_Member be
2152                                           // enough here?
2153                                           Decl::IDNS_Member |
2154                                           Decl::IDNS_Ordinary), Paths)) {
2155      for (BasePaths::decl_iterator I = Paths.found_decls_begin(),
2156           E = Paths.found_decls_end(); I != E; ++I) {
2157        if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2158          OverloadedFunctionDecl::function_iterator MatchedDecl;
2159          // FIXME: Is this OK? Should it be done by LookupInBases?
2160          if (IsOverload(NewMD, OldMD, MatchedDecl))
2161            continue;
2162          if (!OldMD->isVirtual())
2163            continue;
2164
2165          if (!CheckOverridingFunctionReturnType(NewMD, OldMD))
2166            NewMD->addOverriddenMethod(OldMD);
2167        }
2168      }
2169    }
2170  }
2171
2172  if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
2173      !CurContext->isRecord()) {
2174    // C++ [class.static]p1:
2175    //   A data or function member of a class may be declared static
2176    //   in a class definition, in which case it is a static member of
2177    //   the class.
2178
2179    // Complain about the 'static' specifier if it's on an out-of-line
2180    // member function definition.
2181    Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2182         diag::err_static_out_of_line)
2183      << CodeModificationHint::CreateRemoval(
2184                      SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
2185  }
2186
2187  // Handle GNU asm-label extension (encoded as an attribute).
2188  if (Expr *E = (Expr*) D.getAsmLabel()) {
2189    // The parser guarantees this is a string.
2190    StringLiteral *SE = cast<StringLiteral>(E);
2191    NewFD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
2192                                                        SE->getByteLength())));
2193  }
2194
2195  // Copy the parameter declarations from the declarator D to the function
2196  // declaration NewFD, if they are available.  First scavenge them into Params.
2197  llvm::SmallVector<ParmVarDecl*, 16> Params;
2198  if (D.getNumTypeObjects() > 0) {
2199    DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2200
2201    // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2202    // function that takes no arguments, not a function that takes a
2203    // single void argument.
2204    // We let through "const void" here because Sema::GetTypeForDeclarator
2205    // already checks for that case.
2206    if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2207        FTI.ArgInfo[0].Param &&
2208        FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
2209      // Empty arg list, don't push any params.
2210      ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
2211
2212      // In C++, the empty parameter-type-list must be spelled "void"; a
2213      // typedef of void is not permitted.
2214      if (getLangOptions().CPlusPlus &&
2215          Param->getType().getUnqualifiedType() != Context.VoidTy)
2216        Diag(Param->getLocation(), diag::err_param_typedef_of_void);
2217      // FIXME: Leaks decl?
2218    } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
2219      for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i)
2220        Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>());
2221    }
2222
2223  } else if (const FunctionProtoType *FT = R->getAsFunctionProtoType()) {
2224    // When we're declaring a function with a typedef, typeof, etc as in the
2225    // following example, we'll need to synthesize (unnamed)
2226    // parameters for use in the declaration.
2227    //
2228    // @code
2229    // typedef void fn(int);
2230    // fn f;
2231    // @endcode
2232
2233    // Synthesize a parameter for each argument type.
2234    for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2235         AE = FT->arg_type_end(); AI != AE; ++AI) {
2236      ParmVarDecl *Param = ParmVarDecl::Create(Context, DC,
2237                                               SourceLocation(), 0,
2238                                               *AI, VarDecl::None, 0);
2239      Param->setImplicit();
2240      Params.push_back(Param);
2241    }
2242  } else {
2243    assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2244           "Should not need args for typedef of non-prototype fn");
2245  }
2246  // Finally, we know we have the right number of parameters, install them.
2247  NewFD->setParams(Context, Params.data(), Params.size());
2248
2249
2250
2251  // If name lookup finds a previous declaration that is not in the
2252  // same scope as the new declaration, this may still be an
2253  // acceptable redeclaration.
2254  if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
2255      !(NewFD->hasLinkage() &&
2256        isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
2257    PrevDecl = 0;
2258
2259  // Perform semantic checking on the function declaration.
2260  bool OverloadableAttrRequired = false; // FIXME: HACK!
2261  CheckFunctionDeclaration(NewFD, PrevDecl, Redeclaration,
2262                           /*FIXME:*/OverloadableAttrRequired);
2263
2264  if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
2265    // An out-of-line member function declaration must also be a
2266    // definition (C++ [dcl.meaning]p1).
2267    if (!IsFunctionDefinition) {
2268      Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
2269        << D.getCXXScopeSpec().getRange();
2270      NewFD->setInvalidDecl();
2271    } else if (!Redeclaration) {
2272      // The user tried to provide an out-of-line definition for a
2273      // function that is a member of a class or namespace, but there
2274      // was no such member function declared (C++ [class.mfct]p2,
2275      // C++ [namespace.memdef]p2). For example:
2276      //
2277      // class X {
2278      //   void f() const;
2279      // };
2280      //
2281      // void X::f() { } // ill-formed
2282      //
2283      // Complain about this problem, and attempt to suggest close
2284      // matches (e.g., those that differ only in cv-qualifiers and
2285      // whether the parameter types are references).
2286      Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
2287        << cast<NamedDecl>(DC) << D.getCXXScopeSpec().getRange();
2288      NewFD->setInvalidDecl();
2289
2290      LookupResult Prev = LookupQualifiedName(DC, Name, LookupOrdinaryName,
2291                                              true);
2292      assert(!Prev.isAmbiguous() &&
2293             "Cannot have an ambiguity in previous-declaration lookup");
2294      for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
2295           Func != FuncEnd; ++Func) {
2296        if (isa<FunctionDecl>(*Func) &&
2297            isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
2298          Diag((*Func)->getLocation(), diag::note_member_def_close_match);
2299      }
2300
2301      PrevDecl = 0;
2302    }
2303  }
2304
2305  // Handle attributes. We need to have merged decls when handling attributes
2306  // (for example to check for conflicts, etc).
2307  // FIXME: This needs to happen before we merge declarations. Then,
2308  // let attribute merging cope with attribute conflicts.
2309  ProcessDeclAttributes(NewFD, D);
2310  AddKnownFunctionAttributes(NewFD);
2311
2312  if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
2313    // If a function name is overloadable in C, then every function
2314    // with that name must be marked "overloadable".
2315    Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
2316      << Redeclaration << NewFD;
2317    if (PrevDecl)
2318      Diag(PrevDecl->getLocation(),
2319           diag::note_attribute_overloadable_prev_overload);
2320    NewFD->addAttr(::new (Context) OverloadableAttr());
2321  }
2322
2323  // If this is a locally-scoped extern C function, update the
2324  // map of such names.
2325  if (CurContext->isFunctionOrMethod() && NewFD->isExternC(Context)
2326      && !NewFD->isInvalidDecl())
2327    RegisterLocallyScopedExternCDecl(NewFD, PrevDecl, S);
2328
2329  return NewFD;
2330}
2331
2332/// \brief Perform semantic checking of a new function declaration.
2333///
2334/// Performs semantic analysis of the new function declaration
2335/// NewFD. This routine performs all semantic checking that does not
2336/// require the actual declarator involved in the declaration, and is
2337/// used both for the declaration of functions as they are parsed
2338/// (called via ActOnDeclarator) and for the declaration of functions
2339/// that have been instantiated via C++ template instantiation (called
2340/// via InstantiateDecl).
2341///
2342/// This sets NewFD->isInvalidDecl() to true if there was an error.
2343void Sema::CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
2344                                    bool &Redeclaration,
2345                                    bool &OverloadableAttrRequired) {
2346  // If NewFD is already known erroneous, don't do any of this checking.
2347  if (NewFD->isInvalidDecl())
2348    return;
2349
2350  if (NewFD->getResultType()->isVariablyModifiedType()) {
2351    // Functions returning a variably modified type violate C99 6.7.5.2p2
2352    // because all functions have linkage.
2353    Diag(NewFD->getLocation(), diag::err_vm_func_decl);
2354    return NewFD->setInvalidDecl();
2355  }
2356
2357  // Semantic checking for this function declaration (in isolation).
2358  if (getLangOptions().CPlusPlus) {
2359    // C++-specific checks.
2360    if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
2361      CheckConstructor(Constructor);
2362    } else if (isa<CXXDestructorDecl>(NewFD)) {
2363      CXXRecordDecl *Record = cast<CXXRecordDecl>(NewFD->getParent());
2364      Record->setUserDeclaredDestructor(true);
2365      // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
2366      // user-defined destructor.
2367      Record->setPOD(false);
2368
2369      // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
2370      // declared destructor.
2371      Record->setHasTrivialDestructor(false);
2372    } else if (CXXConversionDecl *Conversion
2373               = dyn_cast<CXXConversionDecl>(NewFD))
2374      ActOnConversionDeclarator(Conversion);
2375
2376    // Extra checking for C++ overloaded operators (C++ [over.oper]).
2377    if (NewFD->isOverloadedOperator() &&
2378        CheckOverloadedOperatorDeclaration(NewFD))
2379      return NewFD->setInvalidDecl();
2380  }
2381
2382  // C99 6.7.4p6:
2383  //   [... ] For a function with external linkage, the following
2384  //   restrictions apply: [...] If all of the file scope declarations
2385  //   for a function in a translation unit include the inline
2386  //   function specifier without extern, then the definition in that
2387  //   translation unit is an inline definition. An inline definition
2388  //   does not provide an external definition for the function, and
2389  //   does not forbid an external definition in another translation
2390  //   unit.
2391  //
2392  // Here we determine whether this function, in isolation, would be a
2393  // C99 inline definition. MergeCompatibleFunctionDecls looks at
2394  // previous declarations.
2395  if (NewFD->isInline() && getLangOptions().C99 &&
2396      NewFD->getStorageClass() == FunctionDecl::None &&
2397      NewFD->getDeclContext()->getLookupContext()->isTranslationUnit())
2398    NewFD->setC99InlineDefinition(true);
2399
2400  // Check for a previous declaration of this name.
2401  if (!PrevDecl && NewFD->isExternC(Context)) {
2402    // Since we did not find anything by this name and we're declaring
2403    // an extern "C" function, look for a non-visible extern "C"
2404    // declaration with the same name.
2405    llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2406      = LocallyScopedExternalDecls.find(NewFD->getDeclName());
2407    if (Pos != LocallyScopedExternalDecls.end())
2408      PrevDecl = Pos->second;
2409  }
2410
2411  // Merge or overload the declaration with an existing declaration of
2412  // the same name, if appropriate.
2413  if (PrevDecl) {
2414    // Determine whether NewFD is an overload of PrevDecl or
2415    // a declaration that requires merging. If it's an overload,
2416    // there's no more work to do here; we'll just add the new
2417    // function to the scope.
2418    OverloadedFunctionDecl::function_iterator MatchedDecl;
2419
2420    if (!getLangOptions().CPlusPlus &&
2421        AllowOverloadingOfFunction(PrevDecl, Context)) {
2422      OverloadableAttrRequired = true;
2423
2424      // Functions marked "overloadable" must have a prototype (that
2425      // we can't get through declaration merging).
2426      if (!NewFD->getType()->getAsFunctionProtoType()) {
2427        Diag(NewFD->getLocation(), diag::err_attribute_overloadable_no_prototype)
2428          << NewFD;
2429        Redeclaration = true;
2430
2431        // Turn this into a variadic function with no parameters.
2432        QualType R = Context.getFunctionType(
2433                       NewFD->getType()->getAsFunctionType()->getResultType(),
2434                       0, 0, true, 0);
2435        NewFD->setType(R);
2436        return NewFD->setInvalidDecl();
2437      }
2438    }
2439
2440    if (PrevDecl &&
2441        (!AllowOverloadingOfFunction(PrevDecl, Context) ||
2442         !IsOverload(NewFD, PrevDecl, MatchedDecl))) {
2443      Redeclaration = true;
2444      Decl *OldDecl = PrevDecl;
2445
2446      // If PrevDecl was an overloaded function, extract the
2447      // FunctionDecl that matched.
2448      if (isa<OverloadedFunctionDecl>(PrevDecl))
2449        OldDecl = *MatchedDecl;
2450
2451      // NewFD and OldDecl represent declarations that need to be
2452      // merged.
2453      if (MergeFunctionDecl(NewFD, OldDecl))
2454        return NewFD->setInvalidDecl();
2455
2456      NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
2457    }
2458  }
2459
2460  // In C++, check default arguments now that we have merged decls. Unless
2461  // the lexical context is the class, because in this case this is done
2462  // during delayed parsing anyway.
2463  if (getLangOptions().CPlusPlus && !CurContext->isRecord())
2464    CheckCXXDefaultArguments(NewFD);
2465}
2466
2467bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
2468  // FIXME: Need strict checking.  In C89, we need to check for
2469  // any assignment, increment, decrement, function-calls, or
2470  // commas outside of a sizeof.  In C99, it's the same list,
2471  // except that the aforementioned are allowed in unevaluated
2472  // expressions.  Everything else falls under the
2473  // "may accept other forms of constant expressions" exception.
2474  // (We never end up here for C++, so the constant expression
2475  // rules there don't matter.)
2476  if (Init->isConstantInitializer(Context))
2477    return false;
2478  Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
2479    << Init->getSourceRange();
2480  return true;
2481}
2482
2483void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
2484  AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
2485}
2486
2487/// AddInitializerToDecl - Adds the initializer Init to the
2488/// declaration dcl. If DirectInit is true, this is C++ direct
2489/// initialization rather than copy initialization.
2490void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
2491  Decl *RealDecl = dcl.getAs<Decl>();
2492  // If there is no declaration, there was an error parsing it.  Just ignore
2493  // the initializer.
2494  if (RealDecl == 0)
2495    return;
2496
2497  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
2498    // With declarators parsed the way they are, the parser cannot
2499    // distinguish between a normal initializer and a pure-specifier.
2500    // Thus this grotesque test.
2501    IntegerLiteral *IL;
2502    Expr *Init = static_cast<Expr *>(init.get());
2503    if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
2504        Context.getCanonicalType(IL->getType()) == Context.IntTy) {
2505      if (Method->isVirtualAsWritten()) {
2506        Method->setPure();
2507
2508        // A class is abstract if at least one function is pure virtual.
2509        cast<CXXRecordDecl>(CurContext)->setAbstract(true);
2510      } else if (!Method->isInvalidDecl()) {
2511        Diag(Method->getLocation(), diag::err_non_virtual_pure)
2512          << Method->getDeclName() << Init->getSourceRange();
2513        Method->setInvalidDecl();
2514      }
2515    } else {
2516      Diag(Method->getLocation(), diag::err_member_function_initialization)
2517        << Method->getDeclName() << Init->getSourceRange();
2518      Method->setInvalidDecl();
2519    }
2520    return;
2521  }
2522
2523  VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
2524  if (!VDecl) {
2525    if (getLangOptions().CPlusPlus &&
2526        RealDecl->getLexicalDeclContext()->isRecord() &&
2527        isa<NamedDecl>(RealDecl))
2528      Diag(RealDecl->getLocation(), diag::err_member_initialization)
2529        << cast<NamedDecl>(RealDecl)->getDeclName();
2530    else
2531      Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
2532    RealDecl->setInvalidDecl();
2533    return;
2534  }
2535
2536  if (!VDecl->getType()->isArrayType() &&
2537      RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
2538                          diag::err_typecheck_decl_incomplete_type)) {
2539    RealDecl->setInvalidDecl();
2540    return;
2541  }
2542
2543  const VarDecl *Def = 0;
2544  if (VDecl->getDefinition(Def)) {
2545    Diag(VDecl->getLocation(), diag::err_redefinition)
2546      << VDecl->getDeclName();
2547    Diag(Def->getLocation(), diag::note_previous_definition);
2548    VDecl->setInvalidDecl();
2549    return;
2550  }
2551
2552  // Take ownership of the expression, now that we're sure we have somewhere
2553  // to put it.
2554  Expr *Init = init.takeAs<Expr>();
2555  assert(Init && "missing initializer");
2556
2557  // Get the decls type and save a reference for later, since
2558  // CheckInitializerTypes may change it.
2559  QualType DclT = VDecl->getType(), SavT = DclT;
2560  if (VDecl->isBlockVarDecl()) {
2561    if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
2562      Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
2563      VDecl->setInvalidDecl();
2564    } else if (!VDecl->isInvalidDecl()) {
2565      if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
2566                                VDecl->getDeclName(), DirectInit, VDecl))
2567        VDecl->setInvalidDecl();
2568
2569      // C++ 3.6.2p2, allow dynamic initialization of static initializers.
2570      // Don't check invalid declarations to avoid emitting useless diagnostics.
2571      if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
2572        if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
2573          CheckForConstantInitializer(Init, DclT);
2574      }
2575    }
2576  } else if (VDecl->isStaticDataMember() &&
2577             VDecl->getLexicalDeclContext()->isRecord()) {
2578    // This is an in-class initialization for a static data member, e.g.,
2579    //
2580    // struct S {
2581    //   static const int value = 17;
2582    // };
2583
2584    // Attach the initializer
2585    VDecl->setInit(Context, Init);
2586
2587    // C++ [class.mem]p4:
2588    //   A member-declarator can contain a constant-initializer only
2589    //   if it declares a static member (9.4) of const integral or
2590    //   const enumeration type, see 9.4.2.
2591    QualType T = VDecl->getType();
2592    if (!T->isDependentType() &&
2593        (!Context.getCanonicalType(T).isConstQualified() ||
2594         !T->isIntegralType())) {
2595      Diag(VDecl->getLocation(), diag::err_member_initialization)
2596        << VDecl->getDeclName() << Init->getSourceRange();
2597      VDecl->setInvalidDecl();
2598    } else {
2599      // C++ [class.static.data]p4:
2600      //   If a static data member is of const integral or const
2601      //   enumeration type, its declaration in the class definition
2602      //   can specify a constant-initializer which shall be an
2603      //   integral constant expression (5.19).
2604      if (!Init->isTypeDependent() &&
2605          !Init->getType()->isIntegralType()) {
2606        // We have a non-dependent, non-integral or enumeration type.
2607        Diag(Init->getSourceRange().getBegin(),
2608             diag::err_in_class_initializer_non_integral_type)
2609          << Init->getType() << Init->getSourceRange();
2610        VDecl->setInvalidDecl();
2611      } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
2612        // Check whether the expression is a constant expression.
2613        llvm::APSInt Value;
2614        SourceLocation Loc;
2615        if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
2616          Diag(Loc, diag::err_in_class_initializer_non_constant)
2617            << Init->getSourceRange();
2618          VDecl->setInvalidDecl();
2619        } else if (!VDecl->getType()->isDependentType())
2620          ImpCastExprToType(Init, VDecl->getType());
2621      }
2622    }
2623  } else if (VDecl->isFileVarDecl()) {
2624    if (VDecl->getStorageClass() == VarDecl::Extern)
2625      Diag(VDecl->getLocation(), diag::warn_extern_init);
2626    if (!VDecl->isInvalidDecl())
2627      if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
2628                                VDecl->getDeclName(), DirectInit))
2629        VDecl->setInvalidDecl();
2630
2631    // C++ 3.6.2p2, allow dynamic initialization of static initializers.
2632    // Don't check invalid declarations to avoid emitting useless diagnostics.
2633    if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
2634      // C99 6.7.8p4. All file scoped initializers need to be constant.
2635      CheckForConstantInitializer(Init, DclT);
2636    }
2637  }
2638  // If the type changed, it means we had an incomplete type that was
2639  // completed by the initializer. For example:
2640  //   int ary[] = { 1, 3, 5 };
2641  // "ary" transitions from a VariableArrayType to a ConstantArrayType.
2642  if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
2643    VDecl->setType(DclT);
2644    Init->setType(DclT);
2645  }
2646
2647  // Attach the initializer to the decl.
2648  VDecl->setInit(Context, Init);
2649
2650  // If the previous declaration of VDecl was a tentative definition,
2651  // remove it from the set of tentative definitions.
2652  if (VDecl->getPreviousDeclaration() &&
2653      VDecl->getPreviousDeclaration()->isTentativeDefinition(Context)) {
2654    llvm::DenseMap<DeclarationName, VarDecl *>::iterator Pos
2655      = TentativeDefinitions.find(VDecl->getDeclName());
2656    assert(Pos != TentativeDefinitions.end() &&
2657           "Unrecorded tentative definition?");
2658    TentativeDefinitions.erase(Pos);
2659  }
2660
2661  return;
2662}
2663
2664void Sema::ActOnUninitializedDecl(DeclPtrTy dcl) {
2665  Decl *RealDecl = dcl.getAs<Decl>();
2666
2667  // If there is no declaration, there was an error parsing it. Just ignore it.
2668  if (RealDecl == 0)
2669    return;
2670
2671  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
2672    QualType Type = Var->getType();
2673
2674    // Record tentative definitions.
2675    if (Var->isTentativeDefinition(Context))
2676      TentativeDefinitions[Var->getDeclName()] = Var;
2677
2678    // C++ [dcl.init.ref]p3:
2679    //   The initializer can be omitted for a reference only in a
2680    //   parameter declaration (8.3.5), in the declaration of a
2681    //   function return type, in the declaration of a class member
2682    //   within its class declaration (9.2), and where the extern
2683    //   specifier is explicitly used.
2684    if (Type->isReferenceType() && !Var->hasExternalStorage()) {
2685      Diag(Var->getLocation(), diag::err_reference_var_requires_init)
2686        << Var->getDeclName()
2687        << SourceRange(Var->getLocation(), Var->getLocation());
2688      Var->setInvalidDecl();
2689      return;
2690    }
2691
2692    // C++ [dcl.init]p9:
2693    //
2694    //   If no initializer is specified for an object, and the object
2695    //   is of (possibly cv-qualified) non-POD class type (or array
2696    //   thereof), the object shall be default-initialized; if the
2697    //   object is of const-qualified type, the underlying class type
2698    //   shall have a user-declared default constructor.
2699    if (getLangOptions().CPlusPlus) {
2700      QualType InitType = Type;
2701      if (const ArrayType *Array = Context.getAsArrayType(Type))
2702        InitType = Array->getElementType();
2703      if ((!Var->hasExternalStorage() && !Var->isExternC(Context)) &&
2704          InitType->isRecordType() && !InitType->isDependentType()) {
2705        CXXRecordDecl *RD =
2706          cast<CXXRecordDecl>(InitType->getAsRecordType()->getDecl());
2707        CXXConstructorDecl *Constructor = 0;
2708        if (!RequireCompleteType(Var->getLocation(), InitType,
2709                                    diag::err_invalid_incomplete_type_use))
2710          Constructor
2711            = PerformInitializationByConstructor(InitType, 0, 0,
2712                                                 Var->getLocation(),
2713                                               SourceRange(Var->getLocation(),
2714                                                           Var->getLocation()),
2715                                                 Var->getDeclName(),
2716                                                 IK_Default);
2717        if (!Constructor)
2718          Var->setInvalidDecl();
2719        else if (!RD->hasTrivialConstructor())
2720          InitializeVarWithConstructor(Var, Constructor, InitType, 0, 0);
2721      }
2722    }
2723
2724#if 0
2725    // FIXME: Temporarily disabled because we are not properly parsing
2726    // linkage specifications on declarations, e.g.,
2727    //
2728    //   extern "C" const CGPoint CGPointerZero;
2729    //
2730    // C++ [dcl.init]p9:
2731    //
2732    //     If no initializer is specified for an object, and the
2733    //     object is of (possibly cv-qualified) non-POD class type (or
2734    //     array thereof), the object shall be default-initialized; if
2735    //     the object is of const-qualified type, the underlying class
2736    //     type shall have a user-declared default
2737    //     constructor. Otherwise, if no initializer is specified for
2738    //     an object, the object and its subobjects, if any, have an
2739    //     indeterminate initial value; if the object or any of its
2740    //     subobjects are of const-qualified type, the program is
2741    //     ill-formed.
2742    //
2743    // This isn't technically an error in C, so we don't diagnose it.
2744    //
2745    // FIXME: Actually perform the POD/user-defined default
2746    // constructor check.
2747    if (getLangOptions().CPlusPlus &&
2748        Context.getCanonicalType(Type).isConstQualified() &&
2749        !Var->hasExternalStorage())
2750      Diag(Var->getLocation(),  diag::err_const_var_requires_init)
2751        << Var->getName()
2752        << SourceRange(Var->getLocation(), Var->getLocation());
2753#endif
2754  }
2755}
2756
2757Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
2758                                                   DeclPtrTy *Group,
2759                                                   unsigned NumDecls) {
2760  llvm::SmallVector<Decl*, 8> Decls;
2761
2762  if (DS.isTypeSpecOwned())
2763    Decls.push_back((Decl*)DS.getTypeRep());
2764
2765  for (unsigned i = 0; i != NumDecls; ++i)
2766    if (Decl *D = Group[i].getAs<Decl>())
2767      Decls.push_back(D);
2768
2769  // Perform semantic analysis that depends on having fully processed both
2770  // the declarator and initializer.
2771  for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
2772    VarDecl *IDecl = dyn_cast<VarDecl>(Decls[i]);
2773    if (!IDecl)
2774      continue;
2775    QualType T = IDecl->getType();
2776
2777    // Block scope. C99 6.7p7: If an identifier for an object is declared with
2778    // no linkage (C99 6.2.2p6), the type for the object shall be complete...
2779    if (IDecl->isBlockVarDecl() && !IDecl->hasExternalStorage()) {
2780      if (!IDecl->isInvalidDecl() &&
2781          RequireCompleteType(IDecl->getLocation(), T,
2782                              diag::err_typecheck_decl_incomplete_type))
2783        IDecl->setInvalidDecl();
2784    }
2785    // File scope. C99 6.9.2p2: A declaration of an identifier for and
2786    // object that has file scope without an initializer, and without a
2787    // storage-class specifier or with the storage-class specifier "static",
2788    // constitutes a tentative definition. Note: A tentative definition with
2789    // external linkage is valid (C99 6.2.2p5).
2790    if (IDecl->isTentativeDefinition(Context)) {
2791      QualType CheckType = T;
2792      unsigned DiagID = diag::err_typecheck_decl_incomplete_type;
2793
2794      const IncompleteArrayType *ArrayT = Context.getAsIncompleteArrayType(T);
2795      if (ArrayT) {
2796        CheckType = ArrayT->getElementType();
2797        DiagID = diag::err_illegal_decl_array_incomplete_type;
2798      }
2799
2800      if (IDecl->isInvalidDecl()) {
2801        // Do nothing with invalid declarations
2802      } else if ((ArrayT || IDecl->getStorageClass() == VarDecl::Static) &&
2803                 RequireCompleteType(IDecl->getLocation(), CheckType, DiagID)) {
2804        // C99 6.9.2p3: If the declaration of an identifier for an object is
2805        // a tentative definition and has internal linkage (C99 6.2.2p3), the
2806        // declared type shall not be an incomplete type.
2807        IDecl->setInvalidDecl();
2808      }
2809    }
2810  }
2811  return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
2812                                                   Decls.data(), Decls.size()));
2813}
2814
2815
2816/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
2817/// to introduce parameters into function prototype scope.
2818Sema::DeclPtrTy
2819Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
2820  const DeclSpec &DS = D.getDeclSpec();
2821
2822  // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
2823  VarDecl::StorageClass StorageClass = VarDecl::None;
2824  if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
2825    StorageClass = VarDecl::Register;
2826  } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
2827    Diag(DS.getStorageClassSpecLoc(),
2828         diag::err_invalid_storage_class_in_func_decl);
2829    D.getMutableDeclSpec().ClearStorageClassSpecs();
2830  }
2831
2832  if (D.getDeclSpec().isThreadSpecified())
2833    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2834
2835  DiagnoseFunctionSpecifiers(D);
2836
2837  // Check that there are no default arguments inside the type of this
2838  // parameter (C++ only).
2839  if (getLangOptions().CPlusPlus)
2840    CheckExtraCXXDefaultArguments(D);
2841
2842  TagDecl *OwnedDecl = 0;
2843  QualType parmDeclType = GetTypeForDeclarator(D, S, /*Skip=*/0, &OwnedDecl);
2844
2845  if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
2846    // C++ [dcl.fct]p6:
2847    //   Types shall not be defined in return or parameter types.
2848    Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
2849      << Context.getTypeDeclType(OwnedDecl);
2850  }
2851
2852  // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
2853  // Can this happen for params?  We already checked that they don't conflict
2854  // among each other.  Here they can only shadow globals, which is ok.
2855  IdentifierInfo *II = D.getIdentifier();
2856  if (II) {
2857    if (NamedDecl *PrevDecl = LookupName(S, II, LookupOrdinaryName)) {
2858      if (PrevDecl->isTemplateParameter()) {
2859        // Maybe we will complain about the shadowed template parameter.
2860        DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
2861        // Just pretend that we didn't see the previous declaration.
2862        PrevDecl = 0;
2863      } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
2864        Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
2865
2866        // Recover by removing the name
2867        II = 0;
2868        D.SetIdentifier(0, D.getIdentifierLoc());
2869      }
2870    }
2871  }
2872
2873  // Parameters can not be abstract class types.
2874  // For record types, this is done by the AbstractClassUsageDiagnoser once
2875  // the class has been completely parsed.
2876  if (!CurContext->isRecord() &&
2877      RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
2878                             diag::err_abstract_type_in_decl,
2879                             AbstractParamType))
2880    D.setInvalidType(true);
2881
2882  QualType T = adjustParameterType(parmDeclType);
2883
2884  ParmVarDecl *New;
2885  if (T == parmDeclType) // parameter type did not need adjustment
2886    New = ParmVarDecl::Create(Context, CurContext,
2887                              D.getIdentifierLoc(), II,
2888                              parmDeclType, StorageClass,
2889                              0);
2890  else // keep track of both the adjusted and unadjusted types
2891    New = OriginalParmVarDecl::Create(Context, CurContext,
2892                                      D.getIdentifierLoc(), II, T,
2893                                      parmDeclType, StorageClass, 0);
2894
2895  if (D.isInvalidType())
2896    New->setInvalidDecl();
2897
2898  // Parameter declarators cannot be interface types. All ObjC objects are
2899  // passed by reference.
2900  if (T->isObjCInterfaceType()) {
2901    Diag(D.getIdentifierLoc(),
2902         diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
2903    New->setInvalidDecl();
2904  }
2905
2906  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
2907  if (D.getCXXScopeSpec().isSet()) {
2908    Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
2909      << D.getCXXScopeSpec().getRange();
2910    New->setInvalidDecl();
2911  }
2912
2913  // Add the parameter declaration into this scope.
2914  S->AddDecl(DeclPtrTy::make(New));
2915  if (II)
2916    IdResolver.AddDecl(New);
2917
2918  ProcessDeclAttributes(New, D);
2919
2920  if (New->hasAttr<BlocksAttr>()) {
2921    Diag(New->getLocation(), diag::err_block_on_nonlocal);
2922  }
2923  return DeclPtrTy::make(New);
2924}
2925
2926void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
2927                                           SourceLocation LocAfterDecls) {
2928  assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
2929         "Not a function declarator!");
2930  DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2931
2932  // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
2933  // for a K&R function.
2934  if (!FTI.hasPrototype) {
2935    for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
2936      --i;
2937      if (FTI.ArgInfo[i].Param == 0) {
2938        std::string Code = "  int ";
2939        Code += FTI.ArgInfo[i].Ident->getName();
2940        Code += ";\n";
2941        Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
2942          << FTI.ArgInfo[i].Ident
2943          << CodeModificationHint::CreateInsertion(LocAfterDecls, Code);
2944
2945        // Implicitly declare the argument as type 'int' for lack of a better
2946        // type.
2947        DeclSpec DS;
2948        const char* PrevSpec; // unused
2949        DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
2950                           PrevSpec);
2951        Declarator ParamD(DS, Declarator::KNRTypeListContext);
2952        ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
2953        FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
2954      }
2955    }
2956  }
2957}
2958
2959Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
2960                                              Declarator &D) {
2961  assert(getCurFunctionDecl() == 0 && "Function parsing confused");
2962  assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
2963         "Not a function declarator!");
2964  DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2965
2966  if (FTI.hasPrototype) {
2967    // FIXME: Diagnose arguments without names in C.
2968  }
2969
2970  Scope *ParentScope = FnBodyScope->getParent();
2971
2972  DeclPtrTy DP = ActOnDeclarator(ParentScope, D, /*IsFunctionDefinition=*/true);
2973  return ActOnStartOfFunctionDef(FnBodyScope, DP);
2974}
2975
2976Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
2977  FunctionDecl *FD = cast<FunctionDecl>(D.getAs<Decl>());
2978
2979  CurFunctionNeedsScopeChecking = false;
2980
2981  // See if this is a redefinition.
2982  const FunctionDecl *Definition;
2983  if (FD->getBody(Context, Definition)) {
2984    Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
2985    Diag(Definition->getLocation(), diag::note_previous_definition);
2986  }
2987
2988  // Builtin functions cannot be defined.
2989  if (unsigned BuiltinID = FD->getBuiltinID(Context)) {
2990    if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
2991      Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
2992      FD->setInvalidDecl();
2993    }
2994  }
2995
2996  // The return type of a function definition must be complete
2997  // (C99 6.9.1p3, C++ [dcl.fct]p6).
2998  QualType ResultType = FD->getResultType();
2999  if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
3000      !FD->isInvalidDecl() &&
3001      RequireCompleteType(FD->getLocation(), ResultType,
3002                          diag::err_func_def_incomplete_result))
3003    FD->setInvalidDecl();
3004
3005  // GNU warning -Wmissing-prototypes:
3006  //   Warn if a global function is defined without a previous
3007  //   prototype declaration. This warning is issued even if the
3008  //   definition itself provides a prototype. The aim is to detect
3009  //   global functions that fail to be declared in header files.
3010  if (!FD->isInvalidDecl() && FD->isGlobal() && !isa<CXXMethodDecl>(FD) &&
3011      !FD->isMain()) {
3012    bool MissingPrototype = true;
3013    for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
3014         Prev; Prev = Prev->getPreviousDeclaration()) {
3015      // Ignore any declarations that occur in function or method
3016      // scope, because they aren't visible from the header.
3017      if (Prev->getDeclContext()->isFunctionOrMethod())
3018        continue;
3019
3020      MissingPrototype = !Prev->getType()->isFunctionProtoType();
3021      break;
3022    }
3023
3024    if (MissingPrototype)
3025      Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
3026  }
3027
3028  if (FnBodyScope)
3029    PushDeclContext(FnBodyScope, FD);
3030
3031  // Check the validity of our function parameters
3032  CheckParmsForFunctionDef(FD);
3033
3034  // Introduce our parameters into the function scope
3035  for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
3036    ParmVarDecl *Param = FD->getParamDecl(p);
3037    Param->setOwningFunction(FD);
3038
3039    // If this has an identifier, add it to the scope stack.
3040    if (Param->getIdentifier() && FnBodyScope)
3041      PushOnScopeChains(Param, FnBodyScope);
3042  }
3043
3044  // Checking attributes of current function definition
3045  // dllimport attribute.
3046  if (FD->getAttr<DLLImportAttr>() && (!FD->getAttr<DLLExportAttr>())) {
3047    // dllimport attribute cannot be applied to definition.
3048    if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
3049      Diag(FD->getLocation(),
3050           diag::err_attribute_can_be_applied_only_to_symbol_declaration)
3051        << "dllimport";
3052      FD->setInvalidDecl();
3053      return DeclPtrTy::make(FD);
3054    } else {
3055      // If a symbol previously declared dllimport is later defined, the
3056      // attribute is ignored in subsequent references, and a warning is
3057      // emitted.
3058      Diag(FD->getLocation(),
3059           diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
3060        << FD->getNameAsCString() << "dllimport";
3061    }
3062  }
3063  return DeclPtrTy::make(FD);
3064}
3065
3066Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
3067  return ActOnFinishFunctionBody(D, move(BodyArg), false);
3068}
3069
3070Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
3071                                              bool IsInstantiation) {
3072  Decl *dcl = D.getAs<Decl>();
3073  Stmt *Body = BodyArg.takeAs<Stmt>();
3074  if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(dcl)) {
3075    FD->setBody(Body);
3076    assert(FD == getCurFunctionDecl() && "Function parsing confused");
3077  } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
3078    assert(MD == getCurMethodDecl() && "Method parsing confused");
3079    MD->setBody(Body);
3080  } else {
3081    Body->Destroy(Context);
3082    return DeclPtrTy();
3083  }
3084  if (!IsInstantiation)
3085    PopDeclContext();
3086
3087  // Verify and clean out per-function state.
3088
3089  assert(&getLabelMap() == &FunctionLabelMap && "Didn't pop block right?");
3090
3091  // Check goto/label use.
3092  for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
3093       I = FunctionLabelMap.begin(), E = FunctionLabelMap.end(); I != E; ++I) {
3094    LabelStmt *L = I->second;
3095
3096    // Verify that we have no forward references left.  If so, there was a goto
3097    // or address of a label taken, but no definition of it.  Label fwd
3098    // definitions are indicated with a null substmt.
3099    if (L->getSubStmt() != 0)
3100      continue;
3101
3102    // Emit error.
3103    Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
3104
3105    // At this point, we have gotos that use the bogus label.  Stitch it into
3106    // the function body so that they aren't leaked and that the AST is well
3107    // formed.
3108    if (Body == 0) {
3109      // The whole function wasn't parsed correctly, just delete this.
3110      L->Destroy(Context);
3111      continue;
3112    }
3113
3114    // Otherwise, the body is valid: we want to stitch the label decl into the
3115    // function somewhere so that it is properly owned and so that the goto
3116    // has a valid target.  Do this by creating a new compound stmt with the
3117    // label in it.
3118
3119    // Give the label a sub-statement.
3120    L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
3121
3122    CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
3123                               cast<CXXTryStmt>(Body)->getTryBlock() :
3124                               cast<CompoundStmt>(Body);
3125    std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
3126    Elements.push_back(L);
3127    Compound->setStmts(Context, &Elements[0], Elements.size());
3128  }
3129  FunctionLabelMap.clear();
3130
3131  if (!Body) return D;
3132
3133  // Verify that that gotos and switch cases don't jump into scopes illegally.
3134  if (CurFunctionNeedsScopeChecking)
3135    DiagnoseInvalidJumps(Body);
3136
3137  // C++ constructors that have function-try-blocks can't have return statements
3138  // in the handlers of that block. (C++ [except.handle]p14) Verify this.
3139  if (isa<CXXConstructorDecl>(dcl) && isa<CXXTryStmt>(Body))
3140    DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
3141
3142  return D;
3143}
3144
3145/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
3146/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
3147NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
3148                                          IdentifierInfo &II, Scope *S) {
3149  // Before we produce a declaration for an implicitly defined
3150  // function, see whether there was a locally-scoped declaration of
3151  // this name as a function or variable. If so, use that
3152  // (non-visible) declaration, and complain about it.
3153  llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
3154    = LocallyScopedExternalDecls.find(&II);
3155  if (Pos != LocallyScopedExternalDecls.end()) {
3156    Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
3157    Diag(Pos->second->getLocation(), diag::note_previous_declaration);
3158    return Pos->second;
3159  }
3160
3161  // Extension in C99.  Legal in C90, but warn about it.
3162  if (getLangOptions().C99)
3163    Diag(Loc, diag::ext_implicit_function_decl) << &II;
3164  else
3165    Diag(Loc, diag::warn_implicit_function_decl) << &II;
3166
3167  // FIXME: handle stuff like:
3168  // void foo() { extern float X(); }
3169  // void bar() { X(); }  <-- implicit decl for X in another scope.
3170
3171  // Set a Declarator for the implicit definition: int foo();
3172  const char *Dummy;
3173  DeclSpec DS;
3174  bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy);
3175  Error = Error; // Silence warning.
3176  assert(!Error && "Error setting up implicit decl!");
3177  Declarator D(DS, Declarator::BlockContext);
3178  D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
3179                                             0, 0, false, false, 0,0,0, Loc, D),
3180                SourceLocation());
3181  D.SetIdentifier(&II, Loc);
3182
3183  // Insert this function into translation-unit scope.
3184
3185  DeclContext *PrevDC = CurContext;
3186  CurContext = Context.getTranslationUnitDecl();
3187
3188  FunctionDecl *FD =
3189 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D, DeclPtrTy()).getAs<Decl>());
3190  FD->setImplicit();
3191
3192  CurContext = PrevDC;
3193
3194  AddKnownFunctionAttributes(FD);
3195
3196  return FD;
3197}
3198
3199/// \brief Adds any function attributes that we know a priori based on
3200/// the declaration of this function.
3201///
3202/// These attributes can apply both to implicitly-declared builtins
3203/// (like __builtin___printf_chk) or to library-declared functions
3204/// like NSLog or printf.
3205void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
3206  if (FD->isInvalidDecl())
3207    return;
3208
3209  // If this is a built-in function, map its builtin attributes to
3210  // actual attributes.
3211  if (unsigned BuiltinID = FD->getBuiltinID(Context)) {
3212    // Handle printf-formatting attributes.
3213    unsigned FormatIdx;
3214    bool HasVAListArg;
3215    if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
3216      if (!FD->getAttr<FormatAttr>())
3217        FD->addAttr(::new (Context) FormatAttr("printf", FormatIdx + 1,
3218                                               FormatIdx + 2));
3219    }
3220
3221    // Mark const if we don't care about errno and that is the only
3222    // thing preventing the function from being const. This allows
3223    // IRgen to use LLVM intrinsics for such functions.
3224    if (!getLangOptions().MathErrno &&
3225        Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
3226      if (!FD->getAttr<ConstAttr>())
3227        FD->addAttr(::new (Context) ConstAttr());
3228    }
3229  }
3230
3231  IdentifierInfo *Name = FD->getIdentifier();
3232  if (!Name)
3233    return;
3234  if ((!getLangOptions().CPlusPlus &&
3235       FD->getDeclContext()->isTranslationUnit()) ||
3236      (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
3237       cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
3238       LinkageSpecDecl::lang_c)) {
3239    // Okay: this could be a libc/libm/Objective-C function we know
3240    // about.
3241  } else
3242    return;
3243
3244  if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
3245    if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
3246      // FIXME: We known better than our headers.
3247      const_cast<FormatAttr *>(Format)->setType("printf");
3248    } else
3249      FD->addAttr(::new (Context) FormatAttr("printf", 1, 2));
3250  } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
3251    if (!FD->getAttr<FormatAttr>())
3252      FD->addAttr(::new (Context) FormatAttr("printf", 2, 3));
3253  }
3254}
3255
3256TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T) {
3257  assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
3258  assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
3259
3260  // Scope manipulation handled by caller.
3261  TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
3262                                           D.getIdentifierLoc(),
3263                                           D.getIdentifier(),
3264                                           T);
3265
3266  if (TagType *TT = dyn_cast<TagType>(T)) {
3267    TagDecl *TD = TT->getDecl();
3268
3269    // If the TagDecl that the TypedefDecl points to is an anonymous decl
3270    // keep track of the TypedefDecl.
3271    if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
3272      TD->setTypedefForAnonDecl(NewTD);
3273  }
3274
3275  if (D.isInvalidType())
3276    NewTD->setInvalidDecl();
3277  return NewTD;
3278}
3279
3280
3281/// \brief Determine whether a tag with a given kind is acceptable
3282/// as a redeclaration of the given tag declaration.
3283///
3284/// \returns true if the new tag kind is acceptable, false otherwise.
3285bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
3286                                        TagDecl::TagKind NewTag,
3287                                        SourceLocation NewTagLoc,
3288                                        const IdentifierInfo &Name) {
3289  // C++ [dcl.type.elab]p3:
3290  //   The class-key or enum keyword present in the
3291  //   elaborated-type-specifier shall agree in kind with the
3292  //   declaration to which the name in theelaborated-type-specifier
3293  //   refers. This rule also applies to the form of
3294  //   elaborated-type-specifier that declares a class-name or
3295  //   friend class since it can be construed as referring to the
3296  //   definition of the class. Thus, in any
3297  //   elaborated-type-specifier, the enum keyword shall be used to
3298  //   refer to an enumeration (7.2), the union class-keyshall be
3299  //   used to refer to a union (clause 9), and either the class or
3300  //   struct class-key shall be used to refer to a class (clause 9)
3301  //   declared using the class or struct class-key.
3302  TagDecl::TagKind OldTag = Previous->getTagKind();
3303  if (OldTag == NewTag)
3304    return true;
3305
3306  if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
3307      (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
3308    // Warn about the struct/class tag mismatch.
3309    bool isTemplate = false;
3310    if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
3311      isTemplate = Record->getDescribedClassTemplate();
3312
3313    Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
3314      << (NewTag == TagDecl::TK_class)
3315      << isTemplate << &Name
3316      << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
3317                              OldTag == TagDecl::TK_class? "class" : "struct");
3318    Diag(Previous->getLocation(), diag::note_previous_use);
3319    return true;
3320  }
3321  return false;
3322}
3323
3324/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'.  In the
3325/// former case, Name will be non-null.  In the later case, Name will be null.
3326/// TagSpec indicates what kind of tag this is. TK indicates whether this is a
3327/// reference/declaration/definition of a tag.
3328Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
3329                               SourceLocation KWLoc, const CXXScopeSpec &SS,
3330                               IdentifierInfo *Name, SourceLocation NameLoc,
3331                               AttributeList *Attr, AccessSpecifier AS,
3332                               bool &OwnedDecl) {
3333  // If this is not a definition, it must have a name.
3334  assert((Name != 0 || TK == TK_Definition) &&
3335         "Nameless record must be a definition!");
3336
3337  OwnedDecl = false;
3338  TagDecl::TagKind Kind;
3339  switch (TagSpec) {
3340  default: assert(0 && "Unknown tag type!");
3341  case DeclSpec::TST_struct: Kind = TagDecl::TK_struct; break;
3342  case DeclSpec::TST_union:  Kind = TagDecl::TK_union; break;
3343  case DeclSpec::TST_class:  Kind = TagDecl::TK_class; break;
3344  case DeclSpec::TST_enum:   Kind = TagDecl::TK_enum; break;
3345  }
3346
3347  DeclContext *SearchDC = CurContext;
3348  DeclContext *DC = CurContext;
3349  NamedDecl *PrevDecl = 0;
3350
3351  bool Invalid = false;
3352
3353  if (Name && SS.isNotEmpty()) {
3354    // We have a nested-name tag ('struct foo::bar').
3355
3356    // Check for invalid 'foo::'.
3357    if (SS.isInvalid()) {
3358      Name = 0;
3359      goto CreateNewDecl;
3360    }
3361
3362    if (RequireCompleteDeclContext(SS))
3363      return DeclPtrTy::make((Decl *)0);
3364
3365    DC = computeDeclContext(SS);
3366    SearchDC = DC;
3367    // Look-up name inside 'foo::'.
3368    PrevDecl
3369      = dyn_cast_or_null<TagDecl>(
3370               LookupQualifiedName(DC, Name, LookupTagName, true).getAsDecl());
3371
3372    // A tag 'foo::bar' must already exist.
3373    if (PrevDecl == 0) {
3374      Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
3375      Name = 0;
3376      Invalid = true;
3377      goto CreateNewDecl;
3378    }
3379  } else if (Name) {
3380    // If this is a named struct, check to see if there was a previous forward
3381    // declaration or definition.
3382    // FIXME: We're looking into outer scopes here, even when we
3383    // shouldn't be. Doing so can result in ambiguities that we
3384    // shouldn't be diagnosing.
3385    LookupResult R = LookupName(S, Name, LookupTagName,
3386                                /*RedeclarationOnly=*/(TK != TK_Reference));
3387    if (R.isAmbiguous()) {
3388      DiagnoseAmbiguousLookup(R, Name, NameLoc);
3389      // FIXME: This is not best way to recover from case like:
3390      //
3391      // struct S s;
3392      //
3393      // causes needless "incomplete type" error later.
3394      Name = 0;
3395      PrevDecl = 0;
3396      Invalid = true;
3397    }
3398    else
3399      PrevDecl = R;
3400
3401    if (!getLangOptions().CPlusPlus && TK != TK_Reference) {
3402      // FIXME: This makes sure that we ignore the contexts associated
3403      // with C structs, unions, and enums when looking for a matching
3404      // tag declaration or definition. See the similar lookup tweak
3405      // in Sema::LookupName; is there a better way to deal with this?
3406      while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
3407        SearchDC = SearchDC->getParent();
3408    }
3409  }
3410
3411  if (PrevDecl && PrevDecl->isTemplateParameter()) {
3412    // Maybe we will complain about the shadowed template parameter.
3413    DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
3414    // Just pretend that we didn't see the previous declaration.
3415    PrevDecl = 0;
3416  }
3417
3418  if (PrevDecl) {
3419    // Check whether the previous declaration is usable.
3420    (void)DiagnoseUseOfDecl(PrevDecl, NameLoc);
3421
3422    if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
3423      // If this is a use of a previous tag, or if the tag is already declared
3424      // in the same scope (so that the definition/declaration completes or
3425      // rementions the tag), reuse the decl.
3426      if (TK == TK_Reference || isDeclInScope(PrevDecl, SearchDC, S)) {
3427        // Make sure that this wasn't declared as an enum and now used as a
3428        // struct or something similar.
3429        if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
3430          bool SafeToContinue
3431            = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
3432               Kind != TagDecl::TK_enum);
3433          if (SafeToContinue)
3434            Diag(KWLoc, diag::err_use_with_wrong_tag)
3435              << Name
3436              << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
3437                                                  PrevTagDecl->getKindName());
3438          else
3439            Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
3440          Diag(PrevDecl->getLocation(), diag::note_previous_use);
3441
3442          if (SafeToContinue)
3443            Kind = PrevTagDecl->getTagKind();
3444          else {
3445            // Recover by making this an anonymous redefinition.
3446            Name = 0;
3447            PrevDecl = 0;
3448            Invalid = true;
3449          }
3450        }
3451
3452        if (!Invalid) {
3453          // If this is a use, just return the declaration we found.
3454
3455          // FIXME: In the future, return a variant or some other clue
3456          // for the consumer of this Decl to know it doesn't own it.
3457          // For our current ASTs this shouldn't be a problem, but will
3458          // need to be changed with DeclGroups.
3459          if (TK == TK_Reference)
3460            return DeclPtrTy::make(PrevDecl);
3461
3462          // Diagnose attempts to redefine a tag.
3463          if (TK == TK_Definition) {
3464            if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
3465              Diag(NameLoc, diag::err_redefinition) << Name;
3466              Diag(Def->getLocation(), diag::note_previous_definition);
3467              // If this is a redefinition, recover by making this
3468              // struct be anonymous, which will make any later
3469              // references get the previous definition.
3470              Name = 0;
3471              PrevDecl = 0;
3472              Invalid = true;
3473            } else {
3474              // If the type is currently being defined, complain
3475              // about a nested redefinition.
3476              TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
3477              if (Tag->isBeingDefined()) {
3478                Diag(NameLoc, diag::err_nested_redefinition) << Name;
3479                Diag(PrevTagDecl->getLocation(),
3480                     diag::note_previous_definition);
3481                Name = 0;
3482                PrevDecl = 0;
3483                Invalid = true;
3484              }
3485            }
3486
3487            // Okay, this is definition of a previously declared or referenced
3488            // tag PrevDecl. We're going to create a new Decl for it.
3489          }
3490        }
3491        // If we get here we have (another) forward declaration or we
3492        // have a definition.  Just create a new decl.
3493      } else {
3494        // If we get here, this is a definition of a new tag type in a nested
3495        // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
3496        // new decl/type.  We set PrevDecl to NULL so that the entities
3497        // have distinct types.
3498        PrevDecl = 0;
3499      }
3500      // If we get here, we're going to create a new Decl. If PrevDecl
3501      // is non-NULL, it's a definition of the tag declared by
3502      // PrevDecl. If it's NULL, we have a new definition.
3503    } else {
3504      // PrevDecl is a namespace, template, or anything else
3505      // that lives in the IDNS_Tag identifier namespace.
3506      if (isDeclInScope(PrevDecl, SearchDC, S)) {
3507        // The tag name clashes with a namespace name, issue an error and
3508        // recover by making this tag be anonymous.
3509        Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
3510        Diag(PrevDecl->getLocation(), diag::note_previous_definition);
3511        Name = 0;
3512        PrevDecl = 0;
3513        Invalid = true;
3514      } else {
3515        // The existing declaration isn't relevant to us; we're in a
3516        // new scope, so clear out the previous declaration.
3517        PrevDecl = 0;
3518      }
3519    }
3520  } else if (TK == TK_Reference && SS.isEmpty() && Name &&
3521             (Kind != TagDecl::TK_enum || !getLangOptions().CPlusPlus)) {
3522    // C++ [basic.scope.pdecl]p5:
3523    //   -- for an elaborated-type-specifier of the form
3524    //
3525    //          class-key identifier
3526    //
3527    //      if the elaborated-type-specifier is used in the
3528    //      decl-specifier-seq or parameter-declaration-clause of a
3529    //      function defined in namespace scope, the identifier is
3530    //      declared as a class-name in the namespace that contains
3531    //      the declaration; otherwise, except as a friend
3532    //      declaration, the identifier is declared in the smallest
3533    //      non-class, non-function-prototype scope that contains the
3534    //      declaration.
3535    //
3536    // C99 6.7.2.3p8 has a similar (but not identical!) provision for
3537    // C structs and unions.
3538    //
3539    // GNU C also supports this behavior as part of its incomplete
3540    // enum types extension, while GNU C++ does not.
3541    //
3542    // Find the context where we'll be declaring the tag.
3543    // FIXME: We would like to maintain the current DeclContext as the
3544    // lexical context,
3545    while (SearchDC->isRecord())
3546      SearchDC = SearchDC->getParent();
3547
3548    // Find the scope where we'll be declaring the tag.
3549    while (S->isClassScope() ||
3550           (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
3551           ((S->getFlags() & Scope::DeclScope) == 0) ||
3552           (S->getEntity() &&
3553            ((DeclContext *)S->getEntity())->isTransparentContext()))
3554      S = S->getParent();
3555  }
3556
3557CreateNewDecl:
3558
3559  // If there is an identifier, use the location of the identifier as the
3560  // location of the decl, otherwise use the location of the struct/union
3561  // keyword.
3562  SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
3563
3564  // Otherwise, create a new declaration. If there is a previous
3565  // declaration of the same entity, the two will be linked via
3566  // PrevDecl.
3567  TagDecl *New;
3568
3569  if (Kind == TagDecl::TK_enum) {
3570    // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
3571    // enum X { A, B, C } D;    D should chain to X.
3572    New = EnumDecl::Create(Context, SearchDC, Loc, Name,
3573                           cast_or_null<EnumDecl>(PrevDecl));
3574    // If this is an undefined enum, warn.
3575    if (TK != TK_Definition && !Invalid)  {
3576      unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
3577                                              : diag::ext_forward_ref_enum;
3578      Diag(Loc, DK);
3579    }
3580  } else {
3581    // struct/union/class
3582
3583    // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
3584    // struct X { int A; } D;    D should chain to X.
3585    if (getLangOptions().CPlusPlus)
3586      // FIXME: Look for a way to use RecordDecl for simple structs.
3587      New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name,
3588                                  cast_or_null<CXXRecordDecl>(PrevDecl));
3589    else
3590      New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name,
3591                               cast_or_null<RecordDecl>(PrevDecl));
3592  }
3593
3594  if (Kind != TagDecl::TK_enum) {
3595    // Handle #pragma pack: if the #pragma pack stack has non-default
3596    // alignment, make up a packed attribute for this decl. These
3597    // attributes are checked when the ASTContext lays out the
3598    // structure.
3599    //
3600    // It is important for implementing the correct semantics that this
3601    // happen here (in act on tag decl). The #pragma pack stack is
3602    // maintained as a result of parser callbacks which can occur at
3603    // many points during the parsing of a struct declaration (because
3604    // the #pragma tokens are effectively skipped over during the
3605    // parsing of the struct).
3606    if (unsigned Alignment = getPragmaPackAlignment())
3607      New->addAttr(::new (Context) PackedAttr(Alignment * 8));
3608  }
3609
3610  if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
3611    // C++ [dcl.typedef]p3:
3612    //   [...] Similarly, in a given scope, a class or enumeration
3613    //   shall not be declared with the same name as a typedef-name
3614    //   that is declared in that scope and refers to a type other
3615    //   than the class or enumeration itself.
3616    LookupResult Lookup = LookupName(S, Name, LookupOrdinaryName, true);
3617    TypedefDecl *PrevTypedef = 0;
3618    if (Lookup.getKind() == LookupResult::Found)
3619      PrevTypedef = dyn_cast<TypedefDecl>(Lookup.getAsDecl());
3620
3621    if (PrevTypedef && isDeclInScope(PrevTypedef, SearchDC, S) &&
3622        Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
3623          Context.getCanonicalType(Context.getTypeDeclType(New))) {
3624      Diag(Loc, diag::err_tag_definition_of_typedef)
3625        << Context.getTypeDeclType(New)
3626        << PrevTypedef->getUnderlyingType();
3627      Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
3628      Invalid = true;
3629    }
3630  }
3631
3632  if (Invalid)
3633    New->setInvalidDecl();
3634
3635  if (Attr)
3636    ProcessDeclAttributeList(New, Attr);
3637
3638  // If we're declaring or defining a tag in function prototype scope
3639  // in C, note that this type can only be used within the function.
3640  if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
3641    Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
3642
3643  // Set the lexical context. If the tag has a C++ scope specifier, the
3644  // lexical context will be different from the semantic context.
3645  New->setLexicalDeclContext(CurContext);
3646
3647  // Set the access specifier.
3648  if (!Invalid)
3649    SetMemberAccessSpecifier(New, PrevDecl, AS);
3650
3651  if (TK == TK_Definition)
3652    New->startDefinition();
3653
3654  // If this has an identifier, add it to the scope stack.
3655  if (Name) {
3656    S = getNonFieldDeclScope(S);
3657    PushOnScopeChains(New, S);
3658  } else {
3659    CurContext->addDecl(Context, New);
3660  }
3661
3662  OwnedDecl = true;
3663  return DeclPtrTy::make(New);
3664}
3665
3666void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
3667  AdjustDeclIfTemplate(TagD);
3668  TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
3669
3670  // Enter the tag context.
3671  PushDeclContext(S, Tag);
3672
3673  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Tag)) {
3674    FieldCollector->StartClass();
3675
3676    if (Record->getIdentifier()) {
3677      // C++ [class]p2:
3678      //   [...] The class-name is also inserted into the scope of the
3679      //   class itself; this is known as the injected-class-name. For
3680      //   purposes of access checking, the injected-class-name is treated
3681      //   as if it were a public member name.
3682      CXXRecordDecl *InjectedClassName
3683        = CXXRecordDecl::Create(Context, Record->getTagKind(),
3684                                CurContext, Record->getLocation(),
3685                                Record->getIdentifier(), Record);
3686      InjectedClassName->setImplicit();
3687      InjectedClassName->setAccess(AS_public);
3688      if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
3689        InjectedClassName->setDescribedClassTemplate(Template);
3690      PushOnScopeChains(InjectedClassName, S);
3691      assert(InjectedClassName->isInjectedClassName() &&
3692             "Broken injected-class-name");
3693    }
3694  }
3695}
3696
3697void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD) {
3698  AdjustDeclIfTemplate(TagD);
3699  TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
3700
3701  if (isa<CXXRecordDecl>(Tag))
3702    FieldCollector->FinishClass();
3703
3704  // Exit this scope of this tag's definition.
3705  PopDeclContext();
3706
3707  // Notify the consumer that we've defined a tag.
3708  Consumer.HandleTagDeclDefinition(Tag);
3709}
3710
3711// Note that FieldName may be null for anonymous bitfields.
3712bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
3713                          QualType FieldTy, const Expr *BitWidth) {
3714
3715  // C99 6.7.2.1p4 - verify the field type.
3716  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
3717  if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
3718    // Handle incomplete types with specific error.
3719    if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
3720      return true;
3721    if (FieldName)
3722      return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
3723        << FieldName << FieldTy << BitWidth->getSourceRange();
3724    return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
3725      << FieldTy << BitWidth->getSourceRange();
3726  }
3727
3728  // If the bit-width is type- or value-dependent, don't try to check
3729  // it now.
3730  if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
3731    return false;
3732
3733  llvm::APSInt Value;
3734  if (VerifyIntegerConstantExpression(BitWidth, &Value))
3735    return true;
3736
3737  // Zero-width bitfield is ok for anonymous field.
3738  if (Value == 0 && FieldName)
3739    return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
3740
3741  if (Value.isSigned() && Value.isNegative()) {
3742    if (FieldName)
3743      return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
3744               << FieldName << Value.toString(10);
3745    return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
3746      << Value.toString(10);
3747  }
3748
3749  if (!FieldTy->isDependentType()) {
3750    uint64_t TypeSize = Context.getTypeSize(FieldTy);
3751    if (Value.getZExtValue() > TypeSize) {
3752      if (FieldName)
3753        return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
3754          << FieldName << (unsigned)TypeSize;
3755      return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
3756        << (unsigned)TypeSize;
3757    }
3758  }
3759
3760  return false;
3761}
3762
3763/// ActOnField - Each field of a struct/union/class is passed into this in order
3764/// to create a FieldDecl object for it.
3765Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
3766                                 SourceLocation DeclStart,
3767                                 Declarator &D, ExprTy *BitfieldWidth) {
3768  FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
3769                               DeclStart, D, static_cast<Expr*>(BitfieldWidth),
3770                               AS_public);
3771  return DeclPtrTy::make(Res);
3772}
3773
3774/// HandleField - Analyze a field of a C struct or a C++ data member.
3775///
3776FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
3777                             SourceLocation DeclStart,
3778                             Declarator &D, Expr *BitWidth,
3779                             AccessSpecifier AS) {
3780  IdentifierInfo *II = D.getIdentifier();
3781  SourceLocation Loc = DeclStart;
3782  if (II) Loc = D.getIdentifierLoc();
3783
3784  QualType T = GetTypeForDeclarator(D, S);
3785  if (getLangOptions().CPlusPlus)
3786    CheckExtraCXXDefaultArguments(D);
3787
3788  DiagnoseFunctionSpecifiers(D);
3789
3790  if (D.getDeclSpec().isThreadSpecified())
3791    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3792
3793  NamedDecl *PrevDecl = LookupName(S, II, LookupMemberName, true);
3794  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
3795    PrevDecl = 0;
3796
3797  FieldDecl *NewFD
3798    = CheckFieldDecl(II, T, Record, Loc,
3799               D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable,
3800                     BitWidth, AS, PrevDecl, &D);
3801  if (NewFD->isInvalidDecl() && PrevDecl) {
3802    // Don't introduce NewFD into scope; there's already something
3803    // with the same name in the same scope.
3804  } else if (II) {
3805    PushOnScopeChains(NewFD, S);
3806  } else
3807    Record->addDecl(Context, NewFD);
3808
3809  return NewFD;
3810}
3811
3812/// \brief Build a new FieldDecl and check its well-formedness.
3813///
3814/// This routine builds a new FieldDecl given the fields name, type,
3815/// record, etc. \p PrevDecl should refer to any previous declaration
3816/// with the same name and in the same scope as the field to be
3817/// created.
3818///
3819/// \returns a new FieldDecl.
3820///
3821/// \todo The Declarator argument is a hack. It will be removed once
3822FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
3823                                RecordDecl *Record, SourceLocation Loc,
3824                                bool Mutable, Expr *BitWidth,
3825                                AccessSpecifier AS, NamedDecl *PrevDecl,
3826                                Declarator *D) {
3827  IdentifierInfo *II = Name.getAsIdentifierInfo();
3828  bool InvalidDecl = false;
3829  if (D) InvalidDecl = D->isInvalidType();
3830
3831  // If we receive a broken type, recover by assuming 'int' and
3832  // marking this declaration as invalid.
3833  if (T.isNull()) {
3834    InvalidDecl = true;
3835    T = Context.IntTy;
3836  }
3837
3838  // C99 6.7.2.1p8: A member of a structure or union may have any type other
3839  // than a variably modified type.
3840  if (T->isVariablyModifiedType()) {
3841    bool SizeIsNegative;
3842    QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
3843                                                           SizeIsNegative);
3844    if (!FixedTy.isNull()) {
3845      Diag(Loc, diag::warn_illegal_constant_array_size);
3846      T = FixedTy;
3847    } else {
3848      if (SizeIsNegative)
3849        Diag(Loc, diag::err_typecheck_negative_array_size);
3850      else
3851        Diag(Loc, diag::err_typecheck_field_variable_size);
3852      T = Context.IntTy;
3853      InvalidDecl = true;
3854    }
3855  }
3856
3857  // Fields can not have abstract class types
3858  if (RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl,
3859                             AbstractFieldType))
3860    InvalidDecl = true;
3861
3862  // If this is declared as a bit-field, check the bit-field.
3863  if (BitWidth && VerifyBitField(Loc, II, T, BitWidth)) {
3864    InvalidDecl = true;
3865    DeleteExpr(BitWidth);
3866    BitWidth = 0;
3867  }
3868
3869  FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, BitWidth,
3870                                       Mutable);
3871  if (InvalidDecl)
3872    NewFD->setInvalidDecl();
3873
3874  if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
3875    Diag(Loc, diag::err_duplicate_member) << II;
3876    Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3877    NewFD->setInvalidDecl();
3878  }
3879
3880  if (getLangOptions().CPlusPlus && !T->isPODType())
3881    cast<CXXRecordDecl>(Record)->setPOD(false);
3882
3883  // FIXME: We need to pass in the attributes given an AST
3884  // representation, not a parser representation.
3885  if (D)
3886    ProcessDeclAttributes(NewFD, *D);
3887
3888  if (T.isObjCGCWeak())
3889    Diag(Loc, diag::warn_attribute_weak_on_field);
3890
3891  NewFD->setAccess(AS);
3892
3893  // C++ [dcl.init.aggr]p1:
3894  //   An aggregate is an array or a class (clause 9) with [...] no
3895  //   private or protected non-static data members (clause 11).
3896  // A POD must be an aggregate.
3897  if (getLangOptions().CPlusPlus &&
3898      (AS == AS_private || AS == AS_protected)) {
3899    CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
3900    CXXRecord->setAggregate(false);
3901    CXXRecord->setPOD(false);
3902  }
3903
3904  return NewFD;
3905}
3906
3907/// TranslateIvarVisibility - Translate visibility from a token ID to an
3908///  AST enum value.
3909static ObjCIvarDecl::AccessControl
3910TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
3911  switch (ivarVisibility) {
3912  default: assert(0 && "Unknown visitibility kind");
3913  case tok::objc_private: return ObjCIvarDecl::Private;
3914  case tok::objc_public: return ObjCIvarDecl::Public;
3915  case tok::objc_protected: return ObjCIvarDecl::Protected;
3916  case tok::objc_package: return ObjCIvarDecl::Package;
3917  }
3918}
3919
3920/// ActOnIvar - Each ivar field of an objective-c class is passed into this
3921/// in order to create an IvarDecl object for it.
3922Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
3923                                SourceLocation DeclStart,
3924                                Declarator &D, ExprTy *BitfieldWidth,
3925                                tok::ObjCKeywordKind Visibility) {
3926
3927  IdentifierInfo *II = D.getIdentifier();
3928  Expr *BitWidth = (Expr*)BitfieldWidth;
3929  SourceLocation Loc = DeclStart;
3930  if (II) Loc = D.getIdentifierLoc();
3931
3932  // FIXME: Unnamed fields can be handled in various different ways, for
3933  // example, unnamed unions inject all members into the struct namespace!
3934
3935  QualType T = GetTypeForDeclarator(D, S);
3936
3937  if (BitWidth) {
3938    // 6.7.2.1p3, 6.7.2.1p4
3939    if (VerifyBitField(Loc, II, T, BitWidth)) {
3940      D.setInvalidType();
3941      DeleteExpr(BitWidth);
3942      BitWidth = 0;
3943    }
3944  } else {
3945    // Not a bitfield.
3946
3947    // validate II.
3948
3949  }
3950
3951  // C99 6.7.2.1p8: A member of a structure or union may have any type other
3952  // than a variably modified type.
3953  if (T->isVariablyModifiedType()) {
3954    Diag(Loc, diag::err_typecheck_ivar_variable_size);
3955    D.setInvalidType();
3956  }
3957
3958  // Get the visibility (access control) for this ivar.
3959  ObjCIvarDecl::AccessControl ac =
3960    Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
3961                                        : ObjCIvarDecl::None;
3962
3963  // Construct the decl.
3964  ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, CurContext, Loc, II, T,ac,
3965                                             (Expr *)BitfieldWidth);
3966
3967  if (II) {
3968    NamedDecl *PrevDecl = LookupName(S, II, LookupMemberName, true);
3969    if (PrevDecl && isDeclInScope(PrevDecl, CurContext, S)
3970        && !isa<TagDecl>(PrevDecl)) {
3971      Diag(Loc, diag::err_duplicate_member) << II;
3972      Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3973      NewID->setInvalidDecl();
3974    }
3975  }
3976
3977  // Process attributes attached to the ivar.
3978  ProcessDeclAttributes(NewID, D);
3979
3980  if (D.isInvalidType())
3981    NewID->setInvalidDecl();
3982
3983  if (II) {
3984    // FIXME: When interfaces are DeclContexts, we'll need to add
3985    // these to the interface.
3986    S->AddDecl(DeclPtrTy::make(NewID));
3987    IdResolver.AddDecl(NewID);
3988  }
3989
3990  return DeclPtrTy::make(NewID);
3991}
3992
3993void Sema::ActOnFields(Scope* S,
3994                       SourceLocation RecLoc, DeclPtrTy RecDecl,
3995                       DeclPtrTy *Fields, unsigned NumFields,
3996                       SourceLocation LBrac, SourceLocation RBrac,
3997                       AttributeList *Attr) {
3998  Decl *EnclosingDecl = RecDecl.getAs<Decl>();
3999  assert(EnclosingDecl && "missing record or interface decl");
4000
4001  // If the decl this is being inserted into is invalid, then it may be a
4002  // redeclaration or some other bogus case.  Don't try to add fields to it.
4003  if (EnclosingDecl->isInvalidDecl()) {
4004    // FIXME: Deallocate fields?
4005    return;
4006  }
4007
4008
4009  // Verify that all the fields are okay.
4010  unsigned NumNamedMembers = 0;
4011  llvm::SmallVector<FieldDecl*, 32> RecFields;
4012
4013  RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
4014  for (unsigned i = 0; i != NumFields; ++i) {
4015    FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
4016
4017    // Get the type for the field.
4018    Type *FDTy = FD->getType().getTypePtr();
4019
4020    if (!FD->isAnonymousStructOrUnion()) {
4021      // Remember all fields written by the user.
4022      RecFields.push_back(FD);
4023    }
4024
4025    // If the field is already invalid for some reason, don't emit more
4026    // diagnostics about it.
4027    if (FD->isInvalidDecl())
4028      continue;
4029
4030    // C99 6.7.2.1p2:
4031    //   A structure or union shall not contain a member with
4032    //   incomplete or function type (hence, a structure shall not
4033    //   contain an instance of itself, but may contain a pointer to
4034    //   an instance of itself), except that the last member of a
4035    //   structure with more than one named member may have incomplete
4036    //   array type; such a structure (and any union containing,
4037    //   possibly recursively, a member that is such a structure)
4038    //   shall not be a member of a structure or an element of an
4039    //   array.
4040    if (FDTy->isFunctionType()) {
4041      // Field declared as a function.
4042      Diag(FD->getLocation(), diag::err_field_declared_as_function)
4043        << FD->getDeclName();
4044      FD->setInvalidDecl();
4045      EnclosingDecl->setInvalidDecl();
4046      continue;
4047    } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
4048               Record && Record->isStruct()) {
4049      // Flexible array member.
4050      if (NumNamedMembers < 1) {
4051        Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
4052          << FD->getDeclName();
4053        FD->setInvalidDecl();
4054        EnclosingDecl->setInvalidDecl();
4055        continue;
4056      }
4057      // Okay, we have a legal flexible array member at the end of the struct.
4058      if (Record)
4059        Record->setHasFlexibleArrayMember(true);
4060    } else if (!FDTy->isDependentType() &&
4061               RequireCompleteType(FD->getLocation(), FD->getType(),
4062                                   diag::err_field_incomplete)) {
4063      // Incomplete type
4064      FD->setInvalidDecl();
4065      EnclosingDecl->setInvalidDecl();
4066      continue;
4067    } else if (const RecordType *FDTTy = FDTy->getAsRecordType()) {
4068      if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
4069        // If this is a member of a union, then entire union becomes "flexible".
4070        if (Record && Record->isUnion()) {
4071          Record->setHasFlexibleArrayMember(true);
4072        } else {
4073          // If this is a struct/class and this is not the last element, reject
4074          // it.  Note that GCC supports variable sized arrays in the middle of
4075          // structures.
4076          if (i != NumFields-1)
4077            Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
4078              << FD->getDeclName() << FD->getType();
4079          else {
4080            // We support flexible arrays at the end of structs in
4081            // other structs as an extension.
4082            Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
4083              << FD->getDeclName();
4084            if (Record)
4085              Record->setHasFlexibleArrayMember(true);
4086          }
4087        }
4088      }
4089    } else if (FDTy->isObjCInterfaceType()) {
4090      /// A field cannot be an Objective-c object
4091      Diag(FD->getLocation(), diag::err_statically_allocated_object);
4092      FD->setInvalidDecl();
4093      EnclosingDecl->setInvalidDecl();
4094      continue;
4095    }
4096    // Keep track of the number of named members.
4097    if (FD->getIdentifier())
4098      ++NumNamedMembers;
4099  }
4100
4101  // Okay, we successfully defined 'Record'.
4102  if (Record) {
4103    Record->completeDefinition(Context);
4104  } else {
4105    ObjCIvarDecl **ClsFields =
4106      reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
4107    if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
4108      ID->setIVarList(ClsFields, RecFields.size(), Context);
4109      ID->setLocEnd(RBrac);
4110
4111      // Must enforce the rule that ivars in the base classes may not be
4112      // duplicates.
4113      if (ID->getSuperClass()) {
4114        for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
4115             IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
4116          ObjCIvarDecl* Ivar = (*IVI);
4117
4118          if (IdentifierInfo *II = Ivar->getIdentifier()) {
4119            ObjCIvarDecl* prevIvar =
4120              ID->getSuperClass()->lookupInstanceVariable(Context, II);
4121            if (prevIvar) {
4122              Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
4123              Diag(prevIvar->getLocation(), diag::note_previous_declaration);
4124            }
4125          }
4126        }
4127      }
4128    } else if (ObjCImplementationDecl *IMPDecl =
4129                  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
4130      assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
4131      for (unsigned I = 0, N = RecFields.size(); I != N; ++I) {
4132        // FIXME: Set the DeclContext correctly when we build the
4133        // declarations.
4134        ClsFields[I]->setLexicalDeclContext(IMPDecl);
4135        IMPDecl->addDecl(Context, ClsFields[I]);
4136      }
4137      CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
4138    }
4139  }
4140
4141  if (Attr)
4142    ProcessDeclAttributeList(Record, Attr);
4143}
4144
4145EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
4146                                          EnumConstantDecl *LastEnumConst,
4147                                          SourceLocation IdLoc,
4148                                          IdentifierInfo *Id,
4149                                          ExprArg val) {
4150  Expr *Val = (Expr *)val.get();
4151
4152  llvm::APSInt EnumVal(32);
4153  QualType EltTy;
4154  if (Val && !Val->isTypeDependent()) {
4155    // Make sure to promote the operand type to int.
4156    UsualUnaryConversions(Val);
4157    if (Val != val.get()) {
4158      val.release();
4159      val = Val;
4160    }
4161
4162    // C99 6.7.2.2p2: Make sure we have an integer constant expression.
4163    SourceLocation ExpLoc;
4164    if (!Val->isValueDependent() &&
4165        VerifyIntegerConstantExpression(Val, &EnumVal)) {
4166      Val = 0;
4167    } else {
4168      EltTy = Val->getType();
4169    }
4170  }
4171
4172  if (!Val) {
4173    if (LastEnumConst) {
4174      // Assign the last value + 1.
4175      EnumVal = LastEnumConst->getInitVal();
4176      ++EnumVal;
4177
4178      // Check for overflow on increment.
4179      if (EnumVal < LastEnumConst->getInitVal())
4180        Diag(IdLoc, diag::warn_enum_value_overflow);
4181
4182      EltTy = LastEnumConst->getType();
4183    } else {
4184      // First value, set to zero.
4185      EltTy = Context.IntTy;
4186      EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
4187    }
4188  }
4189
4190  val.release();
4191  return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
4192                                  Val, EnumVal);
4193}
4194
4195
4196Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
4197                                        DeclPtrTy lastEnumConst,
4198                                        SourceLocation IdLoc,
4199                                        IdentifierInfo *Id,
4200                                        SourceLocation EqualLoc, ExprTy *val) {
4201  EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
4202  EnumConstantDecl *LastEnumConst =
4203    cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
4204  Expr *Val = static_cast<Expr*>(val);
4205
4206  // The scope passed in may not be a decl scope.  Zip up the scope tree until
4207  // we find one that is.
4208  S = getNonFieldDeclScope(S);
4209
4210  // Verify that there isn't already something declared with this name in this
4211  // scope.
4212  NamedDecl *PrevDecl = LookupName(S, Id, LookupOrdinaryName);
4213  if (PrevDecl && PrevDecl->isTemplateParameter()) {
4214    // Maybe we will complain about the shadowed template parameter.
4215    DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
4216    // Just pretend that we didn't see the previous declaration.
4217    PrevDecl = 0;
4218  }
4219
4220  if (PrevDecl) {
4221    // When in C++, we may get a TagDecl with the same name; in this case the
4222    // enum constant will 'hide' the tag.
4223    assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
4224           "Received TagDecl when not in C++!");
4225    if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
4226      if (isa<EnumConstantDecl>(PrevDecl))
4227        Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
4228      else
4229        Diag(IdLoc, diag::err_redefinition) << Id;
4230      Diag(PrevDecl->getLocation(), diag::note_previous_definition);
4231      if (Val) Val->Destroy(Context);
4232      return DeclPtrTy();
4233    }
4234  }
4235
4236  EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
4237                                            IdLoc, Id, Owned(Val));
4238
4239  // Register this decl in the current scope stack.
4240  if (New)
4241    PushOnScopeChains(New, S);
4242
4243  return DeclPtrTy::make(New);
4244}
4245
4246void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
4247                         SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
4248                         DeclPtrTy *Elements, unsigned NumElements) {
4249  EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
4250  QualType EnumType = Context.getTypeDeclType(Enum);
4251
4252  // TODO: If the result value doesn't fit in an int, it must be a long or long
4253  // long value.  ISO C does not support this, but GCC does as an extension,
4254  // emit a warning.
4255  unsigned IntWidth = Context.Target.getIntWidth();
4256
4257  // Verify that all the values are okay, compute the size of the values, and
4258  // reverse the list.
4259  unsigned NumNegativeBits = 0;
4260  unsigned NumPositiveBits = 0;
4261
4262  // Keep track of whether all elements have type int.
4263  bool AllElementsInt = true;
4264
4265  for (unsigned i = 0; i != NumElements; ++i) {
4266    EnumConstantDecl *ECD =
4267      cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
4268    if (!ECD) continue;  // Already issued a diagnostic.
4269
4270    // If the enum value doesn't fit in an int, emit an extension warning.
4271    const llvm::APSInt &InitVal = ECD->getInitVal();
4272    assert(InitVal.getBitWidth() >= IntWidth &&
4273           "Should have promoted value to int");
4274    if (InitVal.getBitWidth() > IntWidth) {
4275      llvm::APSInt V(InitVal);
4276      V.trunc(IntWidth);
4277      V.extend(InitVal.getBitWidth());
4278      if (V != InitVal)
4279        Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
4280          << InitVal.toString(10);
4281    }
4282
4283    // Keep track of the size of positive and negative values.
4284    if (InitVal.isUnsigned() || InitVal.isNonNegative())
4285      NumPositiveBits = std::max(NumPositiveBits,
4286                                 (unsigned)InitVal.getActiveBits());
4287    else
4288      NumNegativeBits = std::max(NumNegativeBits,
4289                                 (unsigned)InitVal.getMinSignedBits());
4290
4291    // Keep track of whether every enum element has type int (very commmon).
4292    if (AllElementsInt)
4293      AllElementsInt = ECD->getType() == Context.IntTy;
4294  }
4295
4296  // Figure out the type that should be used for this enum.
4297  // FIXME: Support attribute(packed) on enums and -fshort-enums.
4298  QualType BestType;
4299  unsigned BestWidth;
4300
4301  if (NumNegativeBits) {
4302    // If there is a negative value, figure out the smallest integer type (of
4303    // int/long/longlong) that fits.
4304    if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
4305      BestType = Context.IntTy;
4306      BestWidth = IntWidth;
4307    } else {
4308      BestWidth = Context.Target.getLongWidth();
4309
4310      if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
4311        BestType = Context.LongTy;
4312      else {
4313        BestWidth = Context.Target.getLongLongWidth();
4314
4315        if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
4316          Diag(Enum->getLocation(), diag::warn_enum_too_large);
4317        BestType = Context.LongLongTy;
4318      }
4319    }
4320  } else {
4321    // If there is no negative value, figure out which of uint, ulong, ulonglong
4322    // fits.
4323    if (NumPositiveBits <= IntWidth) {
4324      BestType = Context.UnsignedIntTy;
4325      BestWidth = IntWidth;
4326    } else if (NumPositiveBits <=
4327               (BestWidth = Context.Target.getLongWidth())) {
4328      BestType = Context.UnsignedLongTy;
4329    } else {
4330      BestWidth = Context.Target.getLongLongWidth();
4331      assert(NumPositiveBits <= BestWidth &&
4332             "How could an initializer get larger than ULL?");
4333      BestType = Context.UnsignedLongLongTy;
4334    }
4335  }
4336
4337  // Loop over all of the enumerator constants, changing their types to match
4338  // the type of the enum if needed.
4339  for (unsigned i = 0; i != NumElements; ++i) {
4340    EnumConstantDecl *ECD =
4341      cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
4342    if (!ECD) continue;  // Already issued a diagnostic.
4343
4344    // Standard C says the enumerators have int type, but we allow, as an
4345    // extension, the enumerators to be larger than int size.  If each
4346    // enumerator value fits in an int, type it as an int, otherwise type it the
4347    // same as the enumerator decl itself.  This means that in "enum { X = 1U }"
4348    // that X has type 'int', not 'unsigned'.
4349    if (ECD->getType() == Context.IntTy) {
4350      // Make sure the init value is signed.
4351      llvm::APSInt IV = ECD->getInitVal();
4352      IV.setIsSigned(true);
4353      ECD->setInitVal(IV);
4354
4355      if (getLangOptions().CPlusPlus)
4356        // C++ [dcl.enum]p4: Following the closing brace of an
4357        // enum-specifier, each enumerator has the type of its
4358        // enumeration.
4359        ECD->setType(EnumType);
4360      continue;  // Already int type.
4361    }
4362
4363    // Determine whether the value fits into an int.
4364    llvm::APSInt InitVal = ECD->getInitVal();
4365    bool FitsInInt;
4366    if (InitVal.isUnsigned() || !InitVal.isNegative())
4367      FitsInInt = InitVal.getActiveBits() < IntWidth;
4368    else
4369      FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
4370
4371    // If it fits into an integer type, force it.  Otherwise force it to match
4372    // the enum decl type.
4373    QualType NewTy;
4374    unsigned NewWidth;
4375    bool NewSign;
4376    if (FitsInInt) {
4377      NewTy = Context.IntTy;
4378      NewWidth = IntWidth;
4379      NewSign = true;
4380    } else if (ECD->getType() == BestType) {
4381      // Already the right type!
4382      if (getLangOptions().CPlusPlus)
4383        // C++ [dcl.enum]p4: Following the closing brace of an
4384        // enum-specifier, each enumerator has the type of its
4385        // enumeration.
4386        ECD->setType(EnumType);
4387      continue;
4388    } else {
4389      NewTy = BestType;
4390      NewWidth = BestWidth;
4391      NewSign = BestType->isSignedIntegerType();
4392    }
4393
4394    // Adjust the APSInt value.
4395    InitVal.extOrTrunc(NewWidth);
4396    InitVal.setIsSigned(NewSign);
4397    ECD->setInitVal(InitVal);
4398
4399    // Adjust the Expr initializer and type.
4400    if (ECD->getInitExpr())
4401      ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy, ECD->getInitExpr(),
4402                                                      /*isLvalue=*/false));
4403    if (getLangOptions().CPlusPlus)
4404      // C++ [dcl.enum]p4: Following the closing brace of an
4405      // enum-specifier, each enumerator has the type of its
4406      // enumeration.
4407      ECD->setType(EnumType);
4408    else
4409      ECD->setType(NewTy);
4410  }
4411
4412  Enum->completeDefinition(Context, BestType);
4413}
4414
4415Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
4416                                            ExprArg expr) {
4417  StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
4418
4419  return DeclPtrTy::make(FileScopeAsmDecl::Create(Context, CurContext,
4420                                                  Loc, AsmString));
4421}
4422