SemaDecl.cpp revision eb692e07c71be22d06d38c83ad081a3808bd7f2a
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 "clang/AST/APValue.h"
16#include "clang/AST/ASTConsumer.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/Analysis/CFG.h"
19#include "clang/AST/CXXInheritance.h"
20#include "clang/AST/DeclObjC.h"
21#include "clang/AST/DeclTemplate.h"
22#include "clang/AST/ExprCXX.h"
23#include "clang/AST/StmtCXX.h"
24#include "clang/AST/StmtObjC.h"
25#include "clang/Parse/DeclSpec.h"
26#include "clang/Parse/ParseDiagnostic.h"
27#include "clang/Basic/PartialDiagnostic.h"
28#include "clang/Basic/SourceManager.h"
29#include "clang/Basic/TargetInfo.h"
30// FIXME: layering (ideally, Sema shouldn't be dependent on Lex API's)
31#include "clang/Lex/Preprocessor.h"
32#include "clang/Lex/HeaderSearch.h"
33#include "llvm/ADT/BitVector.h"
34#include "llvm/ADT/STLExtras.h"
35#include <algorithm>
36#include <cstring>
37#include <functional>
38#include <queue>
39using namespace clang;
40
41/// getDeclName - Return a pretty name for the specified decl if possible, or
42/// an empty string if not.  This is used for pretty crash reporting.
43std::string Sema::getDeclName(DeclPtrTy d) {
44  Decl *D = d.getAs<Decl>();
45  if (NamedDecl *DN = dyn_cast_or_null<NamedDecl>(D))
46    return DN->getQualifiedNameAsString();
47  return "";
48}
49
50Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(DeclPtrTy Ptr) {
51  return DeclGroupPtrTy::make(DeclGroupRef(Ptr.getAs<Decl>()));
52}
53
54/// \brief If the identifier refers to a type name within this scope,
55/// return the declaration of that type.
56///
57/// This routine performs ordinary name lookup of the identifier II
58/// within the given scope, with optional C++ scope specifier SS, to
59/// determine whether the name refers to a type. If so, returns an
60/// opaque pointer (actually a QualType) corresponding to that
61/// type. Otherwise, returns NULL.
62///
63/// If name lookup results in an ambiguity, this routine will complain
64/// and then return NULL.
65Sema::TypeTy *Sema::getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
66                                Scope *S, const CXXScopeSpec *SS,
67                                bool isClassName) {
68  // C++ [temp.res]p3:
69  //   A qualified-id that refers to a type and in which the
70  //   nested-name-specifier depends on a template-parameter (14.6.2)
71  //   shall be prefixed by the keyword typename to indicate that the
72  //   qualified-id denotes a type, forming an
73  //   elaborated-type-specifier (7.1.5.3).
74  //
75  // We therefore do not perform any name lookup if the result would
76  // refer to a member of an unknown specialization.
77  if (SS && isUnknownSpecialization(*SS)) {
78    if (!isClassName)
79      return 0;
80
81    // We know from the grammar that this name refers to a type, so build a
82    // TypenameType node to describe the type.
83    // FIXME: Record somewhere that this TypenameType node has no "typename"
84    // keyword associated with it.
85    return CheckTypenameType((NestedNameSpecifier *)SS->getScopeRep(),
86                             II, SS->getRange()).getAsOpaquePtr();
87  }
88
89  LookupResult Result;
90  LookupParsedName(Result, S, SS, &II, LookupOrdinaryName, false, false);
91
92  NamedDecl *IIDecl = 0;
93  switch (Result.getKind()) {
94  case LookupResult::NotFound:
95  case LookupResult::FoundOverloaded:
96    return 0;
97
98  case LookupResult::Ambiguous: {
99    // Recover from type-hiding ambiguities by hiding the type.  We'll
100    // do the lookup again when looking for an object, and we can
101    // diagnose the error then.  If we don't do this, then the error
102    // about hiding the type will be immediately followed by an error
103    // that only makes sense if the identifier was treated like a type.
104    if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding)
105      return 0;
106
107    // Look to see if we have a type anywhere in the list of results.
108    for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
109         Res != ResEnd; ++Res) {
110      if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
111        if (!IIDecl ||
112            (*Res)->getLocation().getRawEncoding() <
113              IIDecl->getLocation().getRawEncoding())
114          IIDecl = *Res;
115      }
116    }
117
118    if (!IIDecl) {
119      // None of the entities we found is a type, so there is no way
120      // to even assume that the result is a type. In this case, don't
121      // complain about the ambiguity. The parser will either try to
122      // perform this lookup again (e.g., as an object name), which
123      // will produce the ambiguity, or will complain that it expected
124      // a type name.
125      return 0;
126    }
127
128    // We found a type within the ambiguous lookup; diagnose the
129    // ambiguity and then return that type. This might be the right
130    // answer, or it might not be, but it suppresses any attempt to
131    // perform the name lookup again.
132    DiagnoseAmbiguousLookup(Result, DeclarationName(&II), NameLoc);
133    break;
134  }
135
136  case LookupResult::Found:
137    IIDecl = Result.getFoundDecl();
138    break;
139  }
140
141  if (IIDecl) {
142    QualType T;
143
144    if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
145      // Check whether we can use this type
146      (void)DiagnoseUseOfDecl(IIDecl, NameLoc);
147
148      if (getLangOptions().CPlusPlus) {
149        // C++ [temp.local]p2:
150        //   Within the scope of a class template specialization or
151        //   partial specialization, when the injected-class-name is
152        //   not followed by a <, it is equivalent to the
153        //   injected-class-name followed by the template-argument s
154        //   of the class template specialization or partial
155        //   specialization enclosed in <>.
156        if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(TD))
157          if (RD->isInjectedClassName())
158            if (ClassTemplateDecl *Template = RD->getDescribedClassTemplate())
159              T = Template->getInjectedClassNameType(Context);
160      }
161
162      if (T.isNull())
163        T = Context.getTypeDeclType(TD);
164    } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
165      // Check whether we can use this interface.
166      (void)DiagnoseUseOfDecl(IIDecl, NameLoc);
167
168      T = Context.getObjCInterfaceType(IDecl);
169    } else
170      return 0;
171
172    if (SS)
173      T = getQualifiedNameType(*SS, T);
174
175    return T.getAsOpaquePtr();
176  }
177
178  return 0;
179}
180
181/// isTagName() - This method is called *for error recovery purposes only*
182/// to determine if the specified name is a valid tag name ("struct foo").  If
183/// so, this returns the TST for the tag corresponding to it (TST_enum,
184/// TST_union, TST_struct, TST_class).  This is used to diagnose cases in C
185/// where the user forgot to specify the tag.
186DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
187  // Do a tag name lookup in this scope.
188  LookupResult R;
189  LookupName(R, S, &II, LookupTagName, false, false);
190  if (R.getKind() == LookupResult::Found)
191    if (const TagDecl *TD = dyn_cast<TagDecl>(R.getAsSingleDecl(Context))) {
192      switch (TD->getTagKind()) {
193      case TagDecl::TK_struct: return DeclSpec::TST_struct;
194      case TagDecl::TK_union:  return DeclSpec::TST_union;
195      case TagDecl::TK_class:  return DeclSpec::TST_class;
196      case TagDecl::TK_enum:   return DeclSpec::TST_enum;
197      }
198    }
199
200  return DeclSpec::TST_unspecified;
201}
202
203bool Sema::DiagnoseUnknownTypeName(const IdentifierInfo &II,
204                                   SourceLocation IILoc,
205                                   Scope *S,
206                                   const CXXScopeSpec *SS,
207                                   TypeTy *&SuggestedType) {
208  // We don't have anything to suggest (yet).
209  SuggestedType = 0;
210
211  // FIXME: Should we move the logic that tries to recover from a missing tag
212  // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
213
214  if (!SS)
215    Diag(IILoc, diag::err_unknown_typename) << &II;
216  else if (DeclContext *DC = computeDeclContext(*SS, false))
217    Diag(IILoc, diag::err_typename_nested_not_found)
218      << &II << DC << SS->getRange();
219  else if (isDependentScopeSpecifier(*SS)) {
220    Diag(SS->getRange().getBegin(), diag::err_typename_missing)
221      << (NestedNameSpecifier *)SS->getScopeRep() << II.getName()
222      << SourceRange(SS->getRange().getBegin(), IILoc)
223      << CodeModificationHint::CreateInsertion(SS->getRange().getBegin(),
224                                               "typename ");
225    SuggestedType = ActOnTypenameType(SourceLocation(), *SS, II, IILoc).get();
226  } else {
227    assert(SS && SS->isInvalid() &&
228           "Invalid scope specifier has already been diagnosed");
229  }
230
231  return true;
232}
233
234// Determines the context to return to after temporarily entering a
235// context.  This depends in an unnecessarily complicated way on the
236// exact ordering of callbacks from the parser.
237DeclContext *Sema::getContainingDC(DeclContext *DC) {
238
239  // Functions defined inline within classes aren't parsed until we've
240  // finished parsing the top-level class, so the top-level class is
241  // the context we'll need to return to.
242  if (isa<FunctionDecl>(DC)) {
243    DC = DC->getLexicalParent();
244
245    // A function not defined within a class will always return to its
246    // lexical context.
247    if (!isa<CXXRecordDecl>(DC))
248      return DC;
249
250    // A C++ inline method/friend is parsed *after* the topmost class
251    // it was declared in is fully parsed ("complete");  the topmost
252    // class is the context we need to return to.
253    while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
254      DC = RD;
255
256    // Return the declaration context of the topmost class the inline method is
257    // declared in.
258    return DC;
259  }
260
261  if (isa<ObjCMethodDecl>(DC))
262    return Context.getTranslationUnitDecl();
263
264  return DC->getLexicalParent();
265}
266
267void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
268  assert(getContainingDC(DC) == CurContext &&
269      "The next DeclContext should be lexically contained in the current one.");
270  CurContext = DC;
271  S->setEntity(DC);
272}
273
274void Sema::PopDeclContext() {
275  assert(CurContext && "DeclContext imbalance!");
276
277  CurContext = getContainingDC(CurContext);
278}
279
280/// EnterDeclaratorContext - Used when we must lookup names in the context
281/// of a declarator's nested name specifier.
282void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
283  assert(PreDeclaratorDC == 0 && "Previous declarator context not popped?");
284  PreDeclaratorDC = static_cast<DeclContext*>(S->getEntity());
285  CurContext = DC;
286  assert(CurContext && "No context?");
287  S->setEntity(CurContext);
288}
289
290void Sema::ExitDeclaratorContext(Scope *S) {
291  S->setEntity(PreDeclaratorDC);
292  PreDeclaratorDC = 0;
293
294  // Reset CurContext to the nearest enclosing context.
295  while (!S->getEntity() && S->getParent())
296    S = S->getParent();
297  CurContext = static_cast<DeclContext*>(S->getEntity());
298  assert(CurContext && "No context?");
299}
300
301/// \brief Determine whether we allow overloading of the function
302/// PrevDecl with another declaration.
303///
304/// This routine determines whether overloading is possible, not
305/// whether some new function is actually an overload. It will return
306/// true in C++ (where we can always provide overloads) or, as an
307/// extension, in C when the previous function is already an
308/// overloaded function declaration or has the "overloadable"
309/// attribute.
310static bool AllowOverloadingOfFunction(Decl *PrevDecl, ASTContext &Context) {
311  if (Context.getLangOptions().CPlusPlus)
312    return true;
313
314  if (isa<OverloadedFunctionDecl>(PrevDecl))
315    return true;
316
317  return PrevDecl->getAttr<OverloadableAttr>() != 0;
318}
319
320/// Add this decl to the scope shadowed decl chains.
321void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
322  // Move up the scope chain until we find the nearest enclosing
323  // non-transparent context. The declaration will be introduced into this
324  // scope.
325  while (S->getEntity() &&
326         ((DeclContext *)S->getEntity())->isTransparentContext())
327    S = S->getParent();
328
329  // Add scoped declarations into their context, so that they can be
330  // found later. Declarations without a context won't be inserted
331  // into any context.
332  if (AddToContext)
333    CurContext->addDecl(D);
334
335  // Out-of-line function and variable definitions should not be pushed into
336  // scope.
337  if ((isa<FunctionTemplateDecl>(D) &&
338       cast<FunctionTemplateDecl>(D)->getTemplatedDecl()->isOutOfLine()) ||
339      (isa<FunctionDecl>(D) && cast<FunctionDecl>(D)->isOutOfLine()) ||
340      (isa<VarDecl>(D) && cast<VarDecl>(D)->isOutOfLine()))
341    return;
342
343  // If this replaces anything in the current scope,
344  IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
345                               IEnd = IdResolver.end();
346  for (; I != IEnd; ++I) {
347    if (S->isDeclScope(DeclPtrTy::make(*I)) && D->declarationReplaces(*I)) {
348      S->RemoveDecl(DeclPtrTy::make(*I));
349      IdResolver.RemoveDecl(*I);
350
351      // Should only need to replace one decl.
352      break;
353    }
354  }
355
356  S->AddDecl(DeclPtrTy::make(D));
357  IdResolver.AddDecl(D);
358}
359
360bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S) {
361  if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) {
362    // Look inside the overload set to determine if any of the declarations
363    // are in scope. (Possibly) build a new overload set containing only
364    // those declarations that are in scope.
365    OverloadedFunctionDecl *NewOvl = 0;
366    bool FoundInScope = false;
367    for (OverloadedFunctionDecl::function_iterator F = Ovl->function_begin(),
368         FEnd = Ovl->function_end();
369         F != FEnd; ++F) {
370      NamedDecl *FD = F->get();
371      if (!isDeclInScope(FD, Ctx, S)) {
372        if (!NewOvl && F != Ovl->function_begin()) {
373          NewOvl = OverloadedFunctionDecl::Create(Context,
374                                                  F->get()->getDeclContext(),
375                                                  F->get()->getDeclName());
376          D = NewOvl;
377          for (OverloadedFunctionDecl::function_iterator
378               First = Ovl->function_begin();
379               First != F; ++First)
380            NewOvl->addOverload(*First);
381        }
382      } else {
383        FoundInScope = true;
384        if (NewOvl)
385          NewOvl->addOverload(*F);
386      }
387    }
388
389    return FoundInScope;
390  }
391
392  return IdResolver.isDeclInScope(D, Ctx, Context, S);
393}
394
395void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
396  if (S->decl_empty()) return;
397  assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
398         "Scope shouldn't contain decls!");
399
400  for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
401       I != E; ++I) {
402    Decl *TmpD = (*I).getAs<Decl>();
403    assert(TmpD && "This decl didn't get pushed??");
404
405    assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
406    NamedDecl *D = cast<NamedDecl>(TmpD);
407
408    if (!D->getDeclName()) continue;
409
410    // Diagnose unused variables in this scope.
411    if (!D->isUsed() && !D->hasAttr<UnusedAttr>() && isa<VarDecl>(D) &&
412        !isa<ParmVarDecl>(D) && !isa<ImplicitParamDecl>(D) &&
413        D->getDeclContext()->isFunctionOrMethod())
414	    Diag(D->getLocation(), diag::warn_unused_variable) << D->getDeclName();
415
416    // Remove this name from our lexical scope.
417    IdResolver.RemoveDecl(D);
418  }
419}
420
421/// getObjCInterfaceDecl - Look up a for a class declaration in the scope.
422/// return 0 if one not found.
423ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *Id) {
424  // The third "scope" argument is 0 since we aren't enabling lazy built-in
425  // creation from this context.
426  NamedDecl *IDecl = LookupSingleName(TUScope, Id, LookupOrdinaryName);
427
428  return dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
429}
430
431/// getNonFieldDeclScope - Retrieves the innermost scope, starting
432/// from S, where a non-field would be declared. This routine copes
433/// with the difference between C and C++ scoping rules in structs and
434/// unions. For example, the following code is well-formed in C but
435/// ill-formed in C++:
436/// @code
437/// struct S6 {
438///   enum { BAR } e;
439/// };
440///
441/// void test_S6() {
442///   struct S6 a;
443///   a.e = BAR;
444/// }
445/// @endcode
446/// For the declaration of BAR, this routine will return a different
447/// scope. The scope S will be the scope of the unnamed enumeration
448/// within S6. In C++, this routine will return the scope associated
449/// with S6, because the enumeration's scope is a transparent
450/// context but structures can contain non-field names. In C, this
451/// routine will return the translation unit scope, since the
452/// enumeration's scope is a transparent context and structures cannot
453/// contain non-field names.
454Scope *Sema::getNonFieldDeclScope(Scope *S) {
455  while (((S->getFlags() & Scope::DeclScope) == 0) ||
456         (S->getEntity() &&
457          ((DeclContext *)S->getEntity())->isTransparentContext()) ||
458         (S->isClassScope() && !getLangOptions().CPlusPlus))
459    S = S->getParent();
460  return S;
461}
462
463void Sema::InitBuiltinVaListType() {
464  if (!Context.getBuiltinVaListType().isNull())
465    return;
466
467  IdentifierInfo *VaIdent = &Context.Idents.get("__builtin_va_list");
468  NamedDecl *VaDecl = LookupSingleName(TUScope, VaIdent, LookupOrdinaryName);
469  TypedefDecl *VaTypedef = cast<TypedefDecl>(VaDecl);
470  Context.setBuiltinVaListType(Context.getTypedefType(VaTypedef));
471}
472
473/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
474/// file scope.  lazily create a decl for it. ForRedeclaration is true
475/// if we're creating this built-in in anticipation of redeclaring the
476/// built-in.
477NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
478                                     Scope *S, bool ForRedeclaration,
479                                     SourceLocation Loc) {
480  Builtin::ID BID = (Builtin::ID)bid;
481
482  if (Context.BuiltinInfo.hasVAListUse(BID))
483    InitBuiltinVaListType();
484
485  ASTContext::GetBuiltinTypeError Error;
486  QualType R = Context.GetBuiltinType(BID, Error);
487  switch (Error) {
488  case ASTContext::GE_None:
489    // Okay
490    break;
491
492  case ASTContext::GE_Missing_stdio:
493    if (ForRedeclaration)
494      Diag(Loc, diag::err_implicit_decl_requires_stdio)
495        << Context.BuiltinInfo.GetName(BID);
496    return 0;
497
498  case ASTContext::GE_Missing_setjmp:
499    if (ForRedeclaration)
500      Diag(Loc, diag::err_implicit_decl_requires_setjmp)
501        << Context.BuiltinInfo.GetName(BID);
502    return 0;
503  }
504
505  if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
506    Diag(Loc, diag::ext_implicit_lib_function_decl)
507      << Context.BuiltinInfo.GetName(BID)
508      << R;
509    if (Context.BuiltinInfo.getHeaderName(BID) &&
510        Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl)
511          != Diagnostic::Ignored)
512      Diag(Loc, diag::note_please_include_header)
513        << Context.BuiltinInfo.getHeaderName(BID)
514        << Context.BuiltinInfo.GetName(BID);
515  }
516
517  FunctionDecl *New = FunctionDecl::Create(Context,
518                                           Context.getTranslationUnitDecl(),
519                                           Loc, II, R, /*DInfo=*/0,
520                                           FunctionDecl::Extern, false,
521                                           /*hasPrototype=*/true);
522  New->setImplicit();
523
524  // Create Decl objects for each parameter, adding them to the
525  // FunctionDecl.
526  if (FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
527    llvm::SmallVector<ParmVarDecl*, 16> Params;
528    for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i)
529      Params.push_back(ParmVarDecl::Create(Context, New, SourceLocation(), 0,
530                                           FT->getArgType(i), /*DInfo=*/0,
531                                           VarDecl::None, 0));
532    New->setParams(Context, Params.data(), Params.size());
533  }
534
535  AddKnownFunctionAttributes(New);
536
537  // TUScope is the translation-unit scope to insert this function into.
538  // FIXME: This is hideous. We need to teach PushOnScopeChains to
539  // relate Scopes to DeclContexts, and probably eliminate CurContext
540  // entirely, but we're not there yet.
541  DeclContext *SavedContext = CurContext;
542  CurContext = Context.getTranslationUnitDecl();
543  PushOnScopeChains(New, TUScope);
544  CurContext = SavedContext;
545  return New;
546}
547
548/// MergeTypeDefDecl - We just parsed a typedef 'New' which has the
549/// same name and scope as a previous declaration 'Old'.  Figure out
550/// how to resolve this situation, merging decls or emitting
551/// diagnostics as appropriate. If there was an error, set New to be invalid.
552///
553void Sema::MergeTypeDefDecl(TypedefDecl *New, Decl *OldD) {
554  // If either decl is known invalid already, set the new one to be invalid and
555  // don't bother doing any merging checks.
556  if (New->isInvalidDecl() || OldD->isInvalidDecl())
557    return New->setInvalidDecl();
558
559  // Allow multiple definitions for ObjC built-in typedefs.
560  // FIXME: Verify the underlying types are equivalent!
561  if (getLangOptions().ObjC1) {
562    const IdentifierInfo *TypeID = New->getIdentifier();
563    switch (TypeID->getLength()) {
564    default: break;
565    case 2:
566      if (!TypeID->isStr("id"))
567        break;
568      Context.ObjCIdRedefinitionType = New->getUnderlyingType();
569      // Install the built-in type for 'id', ignoring the current definition.
570      New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
571      return;
572    case 5:
573      if (!TypeID->isStr("Class"))
574        break;
575      Context.ObjCClassRedefinitionType = New->getUnderlyingType();
576      // Install the built-in type for 'Class', ignoring the current definition.
577      New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
578      return;
579    case 3:
580      if (!TypeID->isStr("SEL"))
581        break;
582      Context.setObjCSelType(Context.getTypeDeclType(New));
583      return;
584    case 8:
585      if (!TypeID->isStr("Protocol"))
586        break;
587      Context.setObjCProtoType(New->getUnderlyingType());
588      return;
589    }
590    // Fall through - the typedef name was not a builtin type.
591  }
592  // Verify the old decl was also a type.
593  TypeDecl *Old = dyn_cast<TypeDecl>(OldD);
594  if (!Old) {
595    Diag(New->getLocation(), diag::err_redefinition_different_kind)
596      << New->getDeclName();
597    if (OldD->getLocation().isValid())
598      Diag(OldD->getLocation(), diag::note_previous_definition);
599    return New->setInvalidDecl();
600  }
601
602  // Determine the "old" type we'll use for checking and diagnostics.
603  QualType OldType;
604  if (TypedefDecl *OldTypedef = dyn_cast<TypedefDecl>(Old))
605    OldType = OldTypedef->getUnderlyingType();
606  else
607    OldType = Context.getTypeDeclType(Old);
608
609  // If the typedef types are not identical, reject them in all languages and
610  // with any extensions enabled.
611
612  if (OldType != New->getUnderlyingType() &&
613      Context.getCanonicalType(OldType) !=
614      Context.getCanonicalType(New->getUnderlyingType())) {
615    Diag(New->getLocation(), diag::err_redefinition_different_typedef)
616      << New->getUnderlyingType() << OldType;
617    if (Old->getLocation().isValid())
618      Diag(Old->getLocation(), diag::note_previous_definition);
619    return New->setInvalidDecl();
620  }
621
622  if (getLangOptions().Microsoft)
623    return;
624
625  // C++ [dcl.typedef]p2:
626  //   In a given non-class scope, a typedef specifier can be used to
627  //   redefine the name of any type declared in that scope to refer
628  //   to the type to which it already refers.
629  if (getLangOptions().CPlusPlus) {
630    if (!isa<CXXRecordDecl>(CurContext))
631      return;
632    Diag(New->getLocation(), diag::err_redefinition)
633      << New->getDeclName();
634    Diag(Old->getLocation(), diag::note_previous_definition);
635    return New->setInvalidDecl();
636  }
637
638  // If we have a redefinition of a typedef in C, emit a warning.  This warning
639  // is normally mapped to an error, but can be controlled with
640  // -Wtypedef-redefinition.  If either the original or the redefinition is
641  // in a system header, don't emit this for compatibility with GCC.
642  if (PP.getDiagnostics().getSuppressSystemWarnings() &&
643      (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
644       Context.getSourceManager().isInSystemHeader(New->getLocation())))
645    return;
646
647  Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
648    << New->getDeclName();
649  Diag(Old->getLocation(), diag::note_previous_definition);
650  return;
651}
652
653/// DeclhasAttr - returns true if decl Declaration already has the target
654/// attribute.
655static bool
656DeclHasAttr(const Decl *decl, const Attr *target) {
657  for (const Attr *attr = decl->getAttrs(); attr; attr = attr->getNext())
658    if (attr->getKind() == target->getKind())
659      return true;
660
661  return false;
662}
663
664/// MergeAttributes - append attributes from the Old decl to the New one.
665static void MergeAttributes(Decl *New, Decl *Old, ASTContext &C) {
666  for (const Attr *attr = Old->getAttrs(); attr; attr = attr->getNext()) {
667    if (!DeclHasAttr(New, attr) && attr->isMerged()) {
668      Attr *NewAttr = attr->clone(C);
669      NewAttr->setInherited(true);
670      New->addAttr(NewAttr);
671    }
672  }
673}
674
675/// Used in MergeFunctionDecl to keep track of function parameters in
676/// C.
677struct GNUCompatibleParamWarning {
678  ParmVarDecl *OldParm;
679  ParmVarDecl *NewParm;
680  QualType PromotedType;
681};
682
683/// MergeFunctionDecl - We just parsed a function 'New' from
684/// declarator D which has the same name and scope as a previous
685/// declaration 'Old'.  Figure out how to resolve this situation,
686/// merging decls or emitting diagnostics as appropriate.
687///
688/// In C++, New and Old must be declarations that are not
689/// overloaded. Use IsOverload to determine whether New and Old are
690/// overloaded, and to select the Old declaration that New should be
691/// merged with.
692///
693/// Returns true if there was an error, false otherwise.
694bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD) {
695  assert(!isa<OverloadedFunctionDecl>(OldD) &&
696         "Cannot merge with an overloaded function declaration");
697
698  // Verify the old decl was also a function.
699  FunctionDecl *Old = 0;
700  if (FunctionTemplateDecl *OldFunctionTemplate
701        = dyn_cast<FunctionTemplateDecl>(OldD))
702    Old = OldFunctionTemplate->getTemplatedDecl();
703  else
704    Old = dyn_cast<FunctionDecl>(OldD);
705  if (!Old) {
706    Diag(New->getLocation(), diag::err_redefinition_different_kind)
707      << New->getDeclName();
708    Diag(OldD->getLocation(), diag::note_previous_definition);
709    return true;
710  }
711
712  // Determine whether the previous declaration was a definition,
713  // implicit declaration, or a declaration.
714  diag::kind PrevDiag;
715  if (Old->isThisDeclarationADefinition())
716    PrevDiag = diag::note_previous_definition;
717  else if (Old->isImplicit())
718    PrevDiag = diag::note_previous_implicit_declaration;
719  else
720    PrevDiag = diag::note_previous_declaration;
721
722  QualType OldQType = Context.getCanonicalType(Old->getType());
723  QualType NewQType = Context.getCanonicalType(New->getType());
724
725  if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
726      New->getStorageClass() == FunctionDecl::Static &&
727      Old->getStorageClass() != FunctionDecl::Static) {
728    Diag(New->getLocation(), diag::err_static_non_static)
729      << New;
730    Diag(Old->getLocation(), PrevDiag);
731    return true;
732  }
733
734  if (getLangOptions().CPlusPlus) {
735    // (C++98 13.1p2):
736    //   Certain function declarations cannot be overloaded:
737    //     -- Function declarations that differ only in the return type
738    //        cannot be overloaded.
739    QualType OldReturnType
740      = cast<FunctionType>(OldQType.getTypePtr())->getResultType();
741    QualType NewReturnType
742      = cast<FunctionType>(NewQType.getTypePtr())->getResultType();
743    if (OldReturnType != NewReturnType) {
744      Diag(New->getLocation(), diag::err_ovl_diff_return_type);
745      Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
746      return true;
747    }
748
749    const CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old);
750    const CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New);
751    if (OldMethod && NewMethod && !NewMethod->getFriendObjectKind() &&
752        NewMethod->getLexicalDeclContext()->isRecord()) {
753      //    -- Member function declarations with the same name and the
754      //       same parameter types cannot be overloaded if any of them
755      //       is a static member function declaration.
756      if (OldMethod->isStatic() || NewMethod->isStatic()) {
757        Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
758        Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
759        return true;
760      }
761
762      // C++ [class.mem]p1:
763      //   [...] A member shall not be declared twice in the
764      //   member-specification, except that a nested class or member
765      //   class template can be declared and then later defined.
766      unsigned NewDiag;
767      if (isa<CXXConstructorDecl>(OldMethod))
768        NewDiag = diag::err_constructor_redeclared;
769      else if (isa<CXXDestructorDecl>(NewMethod))
770        NewDiag = diag::err_destructor_redeclared;
771      else if (isa<CXXConversionDecl>(NewMethod))
772        NewDiag = diag::err_conv_function_redeclared;
773      else
774        NewDiag = diag::err_member_redeclared;
775
776      Diag(New->getLocation(), NewDiag);
777      Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
778    }
779
780    // (C++98 8.3.5p3):
781    //   All declarations for a function shall agree exactly in both the
782    //   return type and the parameter-type-list.
783    if (OldQType == NewQType)
784      return MergeCompatibleFunctionDecls(New, Old);
785
786    // Fall through for conflicting redeclarations and redefinitions.
787  }
788
789  // C: Function types need to be compatible, not identical. This handles
790  // duplicate function decls like "void f(int); void f(enum X);" properly.
791  if (!getLangOptions().CPlusPlus &&
792      Context.typesAreCompatible(OldQType, NewQType)) {
793    const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
794    const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
795    const FunctionProtoType *OldProto = 0;
796    if (isa<FunctionNoProtoType>(NewFuncType) &&
797        (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
798      // The old declaration provided a function prototype, but the
799      // new declaration does not. Merge in the prototype.
800      assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
801      llvm::SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
802                                                 OldProto->arg_type_end());
803      NewQType = Context.getFunctionType(NewFuncType->getResultType(),
804                                         ParamTypes.data(), ParamTypes.size(),
805                                         OldProto->isVariadic(),
806                                         OldProto->getTypeQuals());
807      New->setType(NewQType);
808      New->setHasInheritedPrototype();
809
810      // Synthesize a parameter for each argument type.
811      llvm::SmallVector<ParmVarDecl*, 16> Params;
812      for (FunctionProtoType::arg_type_iterator
813             ParamType = OldProto->arg_type_begin(),
814             ParamEnd = OldProto->arg_type_end();
815           ParamType != ParamEnd; ++ParamType) {
816        ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
817                                                 SourceLocation(), 0,
818                                                 *ParamType, /*DInfo=*/0,
819                                                 VarDecl::None, 0);
820        Param->setImplicit();
821        Params.push_back(Param);
822      }
823
824      New->setParams(Context, Params.data(), Params.size());
825    }
826
827    return MergeCompatibleFunctionDecls(New, Old);
828  }
829
830  // GNU C permits a K&R definition to follow a prototype declaration
831  // if the declared types of the parameters in the K&R definition
832  // match the types in the prototype declaration, even when the
833  // promoted types of the parameters from the K&R definition differ
834  // from the types in the prototype. GCC then keeps the types from
835  // the prototype.
836  //
837  // If a variadic prototype is followed by a non-variadic K&R definition,
838  // the K&R definition becomes variadic.  This is sort of an edge case, but
839  // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
840  // C99 6.9.1p8.
841  if (!getLangOptions().CPlusPlus &&
842      Old->hasPrototype() && !New->hasPrototype() &&
843      New->getType()->getAs<FunctionProtoType>() &&
844      Old->getNumParams() == New->getNumParams()) {
845    llvm::SmallVector<QualType, 16> ArgTypes;
846    llvm::SmallVector<GNUCompatibleParamWarning, 16> Warnings;
847    const FunctionProtoType *OldProto
848      = Old->getType()->getAs<FunctionProtoType>();
849    const FunctionProtoType *NewProto
850      = New->getType()->getAs<FunctionProtoType>();
851
852    // Determine whether this is the GNU C extension.
853    QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
854                                               NewProto->getResultType());
855    bool LooseCompatible = !MergedReturn.isNull();
856    for (unsigned Idx = 0, End = Old->getNumParams();
857         LooseCompatible && Idx != End; ++Idx) {
858      ParmVarDecl *OldParm = Old->getParamDecl(Idx);
859      ParmVarDecl *NewParm = New->getParamDecl(Idx);
860      if (Context.typesAreCompatible(OldParm->getType(),
861                                     NewProto->getArgType(Idx))) {
862        ArgTypes.push_back(NewParm->getType());
863      } else if (Context.typesAreCompatible(OldParm->getType(),
864                                            NewParm->getType())) {
865        GNUCompatibleParamWarning Warn
866          = { OldParm, NewParm, NewProto->getArgType(Idx) };
867        Warnings.push_back(Warn);
868        ArgTypes.push_back(NewParm->getType());
869      } else
870        LooseCompatible = false;
871    }
872
873    if (LooseCompatible) {
874      for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
875        Diag(Warnings[Warn].NewParm->getLocation(),
876             diag::ext_param_promoted_not_compatible_with_prototype)
877          << Warnings[Warn].PromotedType
878          << Warnings[Warn].OldParm->getType();
879        Diag(Warnings[Warn].OldParm->getLocation(),
880             diag::note_previous_declaration);
881      }
882
883      New->setType(Context.getFunctionType(MergedReturn, &ArgTypes[0],
884                                           ArgTypes.size(),
885                                           OldProto->isVariadic(), 0));
886      return MergeCompatibleFunctionDecls(New, Old);
887    }
888
889    // Fall through to diagnose conflicting types.
890  }
891
892  // A function that has already been declared has been redeclared or defined
893  // with a different type- show appropriate diagnostic
894  if (unsigned BuiltinID = Old->getBuiltinID()) {
895    // The user has declared a builtin function with an incompatible
896    // signature.
897    if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
898      // The function the user is redeclaring is a library-defined
899      // function like 'malloc' or 'printf'. Warn about the
900      // redeclaration, then pretend that we don't know about this
901      // library built-in.
902      Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
903      Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
904        << Old << Old->getType();
905      New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
906      Old->setInvalidDecl();
907      return false;
908    }
909
910    PrevDiag = diag::note_previous_builtin_declaration;
911  }
912
913  Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
914  Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
915  return true;
916}
917
918/// \brief Completes the merge of two function declarations that are
919/// known to be compatible.
920///
921/// This routine handles the merging of attributes and other
922/// properties of function declarations form the old declaration to
923/// the new declaration, once we know that New is in fact a
924/// redeclaration of Old.
925///
926/// \returns false
927bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old) {
928  // Merge the attributes
929  MergeAttributes(New, Old, Context);
930
931  // Merge the storage class.
932  if (Old->getStorageClass() != FunctionDecl::Extern &&
933      Old->getStorageClass() != FunctionDecl::None)
934    New->setStorageClass(Old->getStorageClass());
935
936  // Merge "pure" flag.
937  if (Old->isPure())
938    New->setPure();
939
940  // Merge the "deleted" flag.
941  if (Old->isDeleted())
942    New->setDeleted();
943
944  if (getLangOptions().CPlusPlus)
945    return MergeCXXFunctionDecl(New, Old);
946
947  return false;
948}
949
950/// MergeVarDecl - We just parsed a variable 'New' which has the same name
951/// and scope as a previous declaration 'Old'.  Figure out how to resolve this
952/// situation, merging decls or emitting diagnostics as appropriate.
953///
954/// Tentative definition rules (C99 6.9.2p2) are checked by
955/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
956/// definitions here, since the initializer hasn't been attached.
957///
958void Sema::MergeVarDecl(VarDecl *New, Decl *OldD) {
959  // If either decl is invalid, make sure the new one is marked invalid and
960  // don't do any other checking.
961  if (New->isInvalidDecl() || OldD->isInvalidDecl())
962    return New->setInvalidDecl();
963
964  // Verify the old decl was also a variable.
965  VarDecl *Old = dyn_cast<VarDecl>(OldD);
966  if (!Old) {
967    Diag(New->getLocation(), diag::err_redefinition_different_kind)
968      << New->getDeclName();
969    Diag(OldD->getLocation(), diag::note_previous_definition);
970    return New->setInvalidDecl();
971  }
972
973  MergeAttributes(New, Old, Context);
974
975  // Merge the types
976  QualType MergedT;
977  if (getLangOptions().CPlusPlus) {
978    if (Context.hasSameType(New->getType(), Old->getType()))
979      MergedT = New->getType();
980    // C++ [basic.types]p7:
981    //   [...] The declared type of an array object might be an array of
982    //   unknown size and therefore be incomplete at one point in a
983    //   translation unit and complete later on; [...]
984    else if (Old->getType()->isIncompleteArrayType() &&
985             New->getType()->isArrayType()) {
986      CanQual<ArrayType> OldArray
987        = Context.getCanonicalType(Old->getType())->getAs<ArrayType>();
988      CanQual<ArrayType> NewArray
989        = Context.getCanonicalType(New->getType())->getAs<ArrayType>();
990      if (OldArray->getElementType() == NewArray->getElementType())
991        MergedT = New->getType();
992    }
993  } else {
994    MergedT = Context.mergeTypes(New->getType(), Old->getType());
995  }
996  if (MergedT.isNull()) {
997    Diag(New->getLocation(), diag::err_redefinition_different_type)
998      << New->getDeclName();
999    Diag(Old->getLocation(), diag::note_previous_definition);
1000    return New->setInvalidDecl();
1001  }
1002  New->setType(MergedT);
1003
1004  // C99 6.2.2p4: Check if we have a static decl followed by a non-static.
1005  if (New->getStorageClass() == VarDecl::Static &&
1006      (Old->getStorageClass() == VarDecl::None || Old->hasExternalStorage())) {
1007    Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
1008    Diag(Old->getLocation(), diag::note_previous_definition);
1009    return New->setInvalidDecl();
1010  }
1011  // C99 6.2.2p4:
1012  //   For an identifier declared with the storage-class specifier
1013  //   extern in a scope in which a prior declaration of that
1014  //   identifier is visible,23) if the prior declaration specifies
1015  //   internal or external linkage, the linkage of the identifier at
1016  //   the later declaration is the same as the linkage specified at
1017  //   the prior declaration. If no prior declaration is visible, or
1018  //   if the prior declaration specifies no linkage, then the
1019  //   identifier has external linkage.
1020  if (New->hasExternalStorage() && Old->hasLinkage())
1021    /* Okay */;
1022  else if (New->getStorageClass() != VarDecl::Static &&
1023           Old->getStorageClass() == VarDecl::Static) {
1024    Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
1025    Diag(Old->getLocation(), diag::note_previous_definition);
1026    return New->setInvalidDecl();
1027  }
1028
1029  // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
1030
1031  // FIXME: The test for external storage here seems wrong? We still
1032  // need to check for mismatches.
1033  if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
1034      // Don't complain about out-of-line definitions of static members.
1035      !(Old->getLexicalDeclContext()->isRecord() &&
1036        !New->getLexicalDeclContext()->isRecord())) {
1037    Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
1038    Diag(Old->getLocation(), diag::note_previous_definition);
1039    return New->setInvalidDecl();
1040  }
1041
1042  if (New->isThreadSpecified() && !Old->isThreadSpecified()) {
1043    Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
1044    Diag(Old->getLocation(), diag::note_previous_definition);
1045  } else if (!New->isThreadSpecified() && Old->isThreadSpecified()) {
1046    Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
1047    Diag(Old->getLocation(), diag::note_previous_definition);
1048  }
1049
1050  // Keep a chain of previous declarations.
1051  New->setPreviousDeclaration(Old);
1052}
1053
1054/// CheckFallThrough - Check that we don't fall off the end of a
1055/// Statement that should return a value.
1056///
1057/// \returns AlwaysFallThrough iff we always fall off the end of the statement,
1058/// MaybeFallThrough iff we might or might not fall off the end and
1059/// NeverFallThrough iff we never fall off the end of the statement.  We assume
1060/// that functions not marked noreturn will return.
1061Sema::ControlFlowKind Sema::CheckFallThrough(Stmt *Root) {
1062  // FIXME: Eventually share this CFG object when we have other warnings based
1063  // of the CFG.  This can be done using AnalysisContext.
1064  llvm::OwningPtr<CFG> cfg (CFG::buildCFG(Root, &Context));
1065
1066  // FIXME: They should never return 0, fix that, delete this code.
1067  if (cfg == 0)
1068    return NeverFallThrough;
1069  // The CFG leaves in dead things, and we don't want to dead code paths to
1070  // confuse us, so we mark all live things first.
1071  std::queue<CFGBlock*> workq;
1072  llvm::BitVector live(cfg->getNumBlockIDs());
1073  // Prep work queue
1074  workq.push(&cfg->getEntry());
1075  // Solve
1076  while (!workq.empty()) {
1077    CFGBlock *item = workq.front();
1078    workq.pop();
1079    live.set(item->getBlockID());
1080    for (CFGBlock::succ_iterator I=item->succ_begin(),
1081           E=item->succ_end();
1082         I != E;
1083         ++I) {
1084      if ((*I) && !live[(*I)->getBlockID()]) {
1085        live.set((*I)->getBlockID());
1086        workq.push(*I);
1087      }
1088    }
1089  }
1090
1091  // Now we know what is live, we check the live precessors of the exit block
1092  // and look for fall through paths, being careful to ignore normal returns,
1093  // and exceptional paths.
1094  bool HasLiveReturn = false;
1095  bool HasFakeEdge = false;
1096  bool HasPlainEdge = false;
1097  for (CFGBlock::succ_iterator I=cfg->getExit().pred_begin(),
1098         E = cfg->getExit().pred_end();
1099       I != E;
1100       ++I) {
1101    CFGBlock& B = **I;
1102    if (!live[B.getBlockID()])
1103      continue;
1104    if (B.size() == 0) {
1105      // A labeled empty statement, or the entry block...
1106      HasPlainEdge = true;
1107      continue;
1108    }
1109    Stmt *S = B[B.size()-1];
1110    if (isa<ReturnStmt>(S)) {
1111      HasLiveReturn = true;
1112      continue;
1113    }
1114    if (isa<ObjCAtThrowStmt>(S)) {
1115      HasFakeEdge = true;
1116      continue;
1117    }
1118    if (isa<CXXThrowExpr>(S)) {
1119      HasFakeEdge = true;
1120      continue;
1121    }
1122    bool NoReturnEdge = false;
1123    if (CallExpr *C = dyn_cast<CallExpr>(S)) {
1124      Expr *CEE = C->getCallee()->IgnoreParenCasts();
1125      if (CEE->getType().getNoReturnAttr()) {
1126        NoReturnEdge = true;
1127        HasFakeEdge = true;
1128      } else if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {
1129        if (FunctionDecl *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
1130          if (FD->hasAttr<NoReturnAttr>()) {
1131            NoReturnEdge = true;
1132            HasFakeEdge = true;
1133          }
1134        }
1135      }
1136    }
1137    // FIXME: Add noreturn message sends.
1138    if (NoReturnEdge == false)
1139      HasPlainEdge = true;
1140  }
1141  if (!HasPlainEdge)
1142    return NeverFallThrough;
1143  if (HasFakeEdge || HasLiveReturn)
1144    return MaybeFallThrough;
1145  // This says AlwaysFallThrough for calls to functions that are not marked
1146  // noreturn, that don't return.  If people would like this warning to be more
1147  // accurate, such functions should be marked as noreturn.
1148  return AlwaysFallThrough;
1149}
1150
1151/// CheckFallThroughForFunctionDef - Check that we don't fall off the end of a
1152/// function that should return a value.  Check that we don't fall off the end
1153/// of a noreturn function.  We assume that functions and blocks not marked
1154/// noreturn will return.
1155void Sema::CheckFallThroughForFunctionDef(Decl *D, Stmt *Body) {
1156  // FIXME: Would be nice if we had a better way to control cascading errors,
1157  // but for now, avoid them.  The problem is that when Parse sees:
1158  //   int foo() { return a; }
1159  // The return is eaten and the Sema code sees just:
1160  //   int foo() { }
1161  // which this code would then warn about.
1162  if (getDiagnostics().hasErrorOccurred())
1163    return;
1164  bool ReturnsVoid = false;
1165  bool HasNoReturn = false;
1166  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1167    // If the result type of the function is a dependent type, we don't know
1168    // whether it will be void or not, so don't
1169    if (FD->getResultType()->isDependentType())
1170      return;
1171    if (FD->getResultType()->isVoidType())
1172      ReturnsVoid = true;
1173    if (FD->hasAttr<NoReturnAttr>())
1174      HasNoReturn = true;
1175  } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
1176    if (MD->getResultType()->isVoidType())
1177      ReturnsVoid = true;
1178    if (MD->hasAttr<NoReturnAttr>())
1179      HasNoReturn = true;
1180  }
1181
1182  // Short circuit for compilation speed.
1183  if ((Diags.getDiagnosticLevel(diag::warn_maybe_falloff_nonvoid_function)
1184       == Diagnostic::Ignored || ReturnsVoid)
1185      && (Diags.getDiagnosticLevel(diag::warn_noreturn_function_has_return_expr)
1186          == Diagnostic::Ignored || !HasNoReturn)
1187      && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
1188          == Diagnostic::Ignored || !ReturnsVoid))
1189    return;
1190  // FIXME: Function try block
1191  if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) {
1192    switch (CheckFallThrough(Body)) {
1193    case MaybeFallThrough:
1194      if (HasNoReturn)
1195        Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function);
1196      else if (!ReturnsVoid)
1197        Diag(Compound->getRBracLoc(),diag::warn_maybe_falloff_nonvoid_function);
1198      break;
1199    case AlwaysFallThrough:
1200      if (HasNoReturn)
1201        Diag(Compound->getRBracLoc(), diag::warn_falloff_noreturn_function);
1202      else if (!ReturnsVoid)
1203        Diag(Compound->getRBracLoc(), diag::warn_falloff_nonvoid_function);
1204      break;
1205    case NeverFallThrough:
1206      if (ReturnsVoid)
1207        Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_function);
1208      break;
1209    }
1210  }
1211}
1212
1213/// CheckFallThroughForBlock - Check that we don't fall off the end of a block
1214/// that should return a value.  Check that we don't fall off the end of a
1215/// noreturn block.  We assume that functions and blocks not marked noreturn
1216/// will return.
1217void Sema::CheckFallThroughForBlock(QualType BlockTy, Stmt *Body) {
1218  // FIXME: Would be nice if we had a better way to control cascading errors,
1219  // but for now, avoid them.  The problem is that when Parse sees:
1220  //   int foo() { return a; }
1221  // The return is eaten and the Sema code sees just:
1222  //   int foo() { }
1223  // which this code would then warn about.
1224  if (getDiagnostics().hasErrorOccurred())
1225    return;
1226  bool ReturnsVoid = false;
1227  bool HasNoReturn = false;
1228  if (const FunctionType *FT = BlockTy->getPointeeType()->getAs<FunctionType>()) {
1229    if (FT->getResultType()->isVoidType())
1230      ReturnsVoid = true;
1231    if (FT->getNoReturnAttr())
1232      HasNoReturn = true;
1233  }
1234
1235  // Short circuit for compilation speed.
1236  if (ReturnsVoid
1237      && !HasNoReturn
1238      && (Diags.getDiagnosticLevel(diag::warn_suggest_noreturn_block)
1239          == Diagnostic::Ignored || !ReturnsVoid))
1240    return;
1241  // FIXME: Funtion try block
1242  if (CompoundStmt *Compound = dyn_cast<CompoundStmt>(Body)) {
1243    switch (CheckFallThrough(Body)) {
1244    case MaybeFallThrough:
1245      if (HasNoReturn)
1246        Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr);
1247      else if (!ReturnsVoid)
1248        Diag(Compound->getRBracLoc(), diag::err_maybe_falloff_nonvoid_block);
1249      break;
1250    case AlwaysFallThrough:
1251      if (HasNoReturn)
1252        Diag(Compound->getRBracLoc(), diag::err_noreturn_block_has_return_expr);
1253      else if (!ReturnsVoid)
1254        Diag(Compound->getRBracLoc(), diag::err_falloff_nonvoid_block);
1255      break;
1256    case NeverFallThrough:
1257      if (ReturnsVoid)
1258        Diag(Compound->getLBracLoc(), diag::warn_suggest_noreturn_block);
1259      break;
1260    }
1261  }
1262}
1263
1264/// CheckParmsForFunctionDef - Check that the parameters of the given
1265/// function are appropriate for the definition of a function. This
1266/// takes care of any checks that cannot be performed on the
1267/// declaration itself, e.g., that the types of each of the function
1268/// parameters are complete.
1269bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
1270  bool HasInvalidParm = false;
1271  for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
1272    ParmVarDecl *Param = FD->getParamDecl(p);
1273
1274    // C99 6.7.5.3p4: the parameters in a parameter type list in a
1275    // function declarator that is part of a function definition of
1276    // that function shall not have incomplete type.
1277    //
1278    // This is also C++ [dcl.fct]p6.
1279    if (!Param->isInvalidDecl() &&
1280        RequireCompleteType(Param->getLocation(), Param->getType(),
1281                               diag::err_typecheck_decl_incomplete_type)) {
1282      Param->setInvalidDecl();
1283      HasInvalidParm = true;
1284    }
1285
1286    // C99 6.9.1p5: If the declarator includes a parameter type list, the
1287    // declaration of each parameter shall include an identifier.
1288    if (Param->getIdentifier() == 0 &&
1289        !Param->isImplicit() &&
1290        !getLangOptions().CPlusPlus)
1291      Diag(Param->getLocation(), diag::err_parameter_name_omitted);
1292  }
1293
1294  return HasInvalidParm;
1295}
1296
1297/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
1298/// no declarator (e.g. "struct foo;") is parsed.
1299Sema::DeclPtrTy Sema::ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) {
1300  // FIXME: Error on auto/register at file scope
1301  // FIXME: Error on inline/virtual/explicit
1302  // FIXME: Error on invalid restrict
1303  // FIXME: Warn on useless __thread
1304  // FIXME: Warn on useless const/volatile
1305  // FIXME: Warn on useless static/extern/typedef/private_extern/mutable
1306  // FIXME: Warn on useless attributes
1307  Decl *TagD = 0;
1308  TagDecl *Tag = 0;
1309  if (DS.getTypeSpecType() == DeclSpec::TST_class ||
1310      DS.getTypeSpecType() == DeclSpec::TST_struct ||
1311      DS.getTypeSpecType() == DeclSpec::TST_union ||
1312      DS.getTypeSpecType() == DeclSpec::TST_enum) {
1313    TagD = static_cast<Decl *>(DS.getTypeRep());
1314
1315    if (!TagD) // We probably had an error
1316      return DeclPtrTy();
1317
1318    // Note that the above type specs guarantee that the
1319    // type rep is a Decl, whereas in many of the others
1320    // it's a Type.
1321    Tag = dyn_cast<TagDecl>(TagD);
1322  }
1323
1324  if (DS.isFriendSpecified()) {
1325    // If we're dealing with a class template decl, assume that the
1326    // template routines are handling it.
1327    if (TagD && isa<ClassTemplateDecl>(TagD))
1328      return DeclPtrTy();
1329    return ActOnFriendTypeDecl(S, DS, MultiTemplateParamsArg(*this, 0, 0));
1330  }
1331
1332  if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
1333    if (!Record->getDeclName() && Record->isDefinition() &&
1334        DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
1335      if (getLangOptions().CPlusPlus ||
1336          Record->getDeclContext()->isRecord())
1337        return BuildAnonymousStructOrUnion(S, DS, Record);
1338
1339      Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1340        << DS.getSourceRange();
1341    }
1342
1343    // Microsoft allows unnamed struct/union fields. Don't complain
1344    // about them.
1345    // FIXME: Should we support Microsoft's extensions in this area?
1346    if (Record->getDeclName() && getLangOptions().Microsoft)
1347      return DeclPtrTy::make(Tag);
1348  }
1349
1350  if (!DS.isMissingDeclaratorOk() &&
1351      DS.getTypeSpecType() != DeclSpec::TST_error) {
1352    // Warn about typedefs of enums without names, since this is an
1353    // extension in both Microsoft an GNU.
1354    if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef &&
1355        Tag && isa<EnumDecl>(Tag)) {
1356      Diag(DS.getSourceRange().getBegin(), diag::ext_typedef_without_a_name)
1357        << DS.getSourceRange();
1358      return DeclPtrTy::make(Tag);
1359    }
1360
1361    Diag(DS.getSourceRange().getBegin(), diag::err_no_declarators)
1362      << DS.getSourceRange();
1363    return DeclPtrTy();
1364  }
1365
1366  return DeclPtrTy::make(Tag);
1367}
1368
1369/// InjectAnonymousStructOrUnionMembers - Inject the members of the
1370/// anonymous struct or union AnonRecord into the owning context Owner
1371/// and scope S. This routine will be invoked just after we realize
1372/// that an unnamed union or struct is actually an anonymous union or
1373/// struct, e.g.,
1374///
1375/// @code
1376/// union {
1377///   int i;
1378///   float f;
1379/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
1380///    // f into the surrounding scope.x
1381/// @endcode
1382///
1383/// This routine is recursive, injecting the names of nested anonymous
1384/// structs/unions into the owning context and scope as well.
1385bool Sema::InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
1386                                               RecordDecl *AnonRecord) {
1387  bool Invalid = false;
1388  for (RecordDecl::field_iterator F = AnonRecord->field_begin(),
1389                               FEnd = AnonRecord->field_end();
1390       F != FEnd; ++F) {
1391    if ((*F)->getDeclName()) {
1392      LookupResult R;
1393      LookupQualifiedName(R, Owner, (*F)->getDeclName(),
1394                          LookupOrdinaryName, true);
1395      NamedDecl *PrevDecl = R.getAsSingleDecl(Context);
1396      if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
1397        // C++ [class.union]p2:
1398        //   The names of the members of an anonymous union shall be
1399        //   distinct from the names of any other entity in the
1400        //   scope in which the anonymous union is declared.
1401        unsigned diagKind
1402          = AnonRecord->isUnion()? diag::err_anonymous_union_member_redecl
1403                                 : diag::err_anonymous_struct_member_redecl;
1404        Diag((*F)->getLocation(), diagKind)
1405          << (*F)->getDeclName();
1406        Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
1407        Invalid = true;
1408      } else {
1409        // C++ [class.union]p2:
1410        //   For the purpose of name lookup, after the anonymous union
1411        //   definition, the members of the anonymous union are
1412        //   considered to have been defined in the scope in which the
1413        //   anonymous union is declared.
1414        Owner->makeDeclVisibleInContext(*F);
1415        S->AddDecl(DeclPtrTy::make(*F));
1416        IdResolver.AddDecl(*F);
1417      }
1418    } else if (const RecordType *InnerRecordType
1419                 = (*F)->getType()->getAs<RecordType>()) {
1420      RecordDecl *InnerRecord = InnerRecordType->getDecl();
1421      if (InnerRecord->isAnonymousStructOrUnion())
1422        Invalid = Invalid ||
1423          InjectAnonymousStructOrUnionMembers(S, Owner, InnerRecord);
1424    }
1425  }
1426
1427  return Invalid;
1428}
1429
1430/// ActOnAnonymousStructOrUnion - Handle the declaration of an
1431/// anonymous structure or union. Anonymous unions are a C++ feature
1432/// (C++ [class.union]) and a GNU C extension; anonymous structures
1433/// are a GNU C and GNU C++ extension.
1434Sema::DeclPtrTy Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
1435                                                  RecordDecl *Record) {
1436  DeclContext *Owner = Record->getDeclContext();
1437
1438  // Diagnose whether this anonymous struct/union is an extension.
1439  if (Record->isUnion() && !getLangOptions().CPlusPlus)
1440    Diag(Record->getLocation(), diag::ext_anonymous_union);
1441  else if (!Record->isUnion())
1442    Diag(Record->getLocation(), diag::ext_anonymous_struct);
1443
1444  // C and C++ require different kinds of checks for anonymous
1445  // structs/unions.
1446  bool Invalid = false;
1447  if (getLangOptions().CPlusPlus) {
1448    const char* PrevSpec = 0;
1449    unsigned DiagID;
1450    // C++ [class.union]p3:
1451    //   Anonymous unions declared in a named namespace or in the
1452    //   global namespace shall be declared static.
1453    if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
1454        (isa<TranslationUnitDecl>(Owner) ||
1455         (isa<NamespaceDecl>(Owner) &&
1456          cast<NamespaceDecl>(Owner)->getDeclName()))) {
1457      Diag(Record->getLocation(), diag::err_anonymous_union_not_static);
1458      Invalid = true;
1459
1460      // Recover by adding 'static'.
1461      DS.SetStorageClassSpec(DeclSpec::SCS_static, SourceLocation(),
1462                             PrevSpec, DiagID);
1463    }
1464    // C++ [class.union]p3:
1465    //   A storage class is not allowed in a declaration of an
1466    //   anonymous union in a class scope.
1467    else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
1468             isa<RecordDecl>(Owner)) {
1469      Diag(DS.getStorageClassSpecLoc(),
1470           diag::err_anonymous_union_with_storage_spec);
1471      Invalid = true;
1472
1473      // Recover by removing the storage specifier.
1474      DS.SetStorageClassSpec(DeclSpec::SCS_unspecified, SourceLocation(),
1475                             PrevSpec, DiagID);
1476    }
1477
1478    // C++ [class.union]p2:
1479    //   The member-specification of an anonymous union shall only
1480    //   define non-static data members. [Note: nested types and
1481    //   functions cannot be declared within an anonymous union. ]
1482    for (DeclContext::decl_iterator Mem = Record->decls_begin(),
1483                                 MemEnd = Record->decls_end();
1484         Mem != MemEnd; ++Mem) {
1485      if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
1486        // C++ [class.union]p3:
1487        //   An anonymous union shall not have private or protected
1488        //   members (clause 11).
1489        if (FD->getAccess() == AS_protected || FD->getAccess() == AS_private) {
1490          Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
1491            << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
1492          Invalid = true;
1493        }
1494      } else if ((*Mem)->isImplicit()) {
1495        // Any implicit members are fine.
1496      } else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
1497        // This is a type that showed up in an
1498        // elaborated-type-specifier inside the anonymous struct or
1499        // union, but which actually declares a type outside of the
1500        // anonymous struct or union. It's okay.
1501      } else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
1502        if (!MemRecord->isAnonymousStructOrUnion() &&
1503            MemRecord->getDeclName()) {
1504          // This is a nested type declaration.
1505          Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
1506            << (int)Record->isUnion();
1507          Invalid = true;
1508        }
1509      } else {
1510        // We have something that isn't a non-static data
1511        // member. Complain about it.
1512        unsigned DK = diag::err_anonymous_record_bad_member;
1513        if (isa<TypeDecl>(*Mem))
1514          DK = diag::err_anonymous_record_with_type;
1515        else if (isa<FunctionDecl>(*Mem))
1516          DK = diag::err_anonymous_record_with_function;
1517        else if (isa<VarDecl>(*Mem))
1518          DK = diag::err_anonymous_record_with_static;
1519        Diag((*Mem)->getLocation(), DK)
1520            << (int)Record->isUnion();
1521          Invalid = true;
1522      }
1523    }
1524  }
1525
1526  if (!Record->isUnion() && !Owner->isRecord()) {
1527    Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
1528      << (int)getLangOptions().CPlusPlus;
1529    Invalid = true;
1530  }
1531
1532  // Mock up a declarator.
1533  Declarator Dc(DS, Declarator::TypeNameContext);
1534  DeclaratorInfo *DInfo = 0;
1535  GetTypeForDeclarator(Dc, S, &DInfo);
1536  assert(DInfo && "couldn't build declarator info for anonymous struct/union");
1537
1538  // Create a declaration for this anonymous struct/union.
1539  NamedDecl *Anon = 0;
1540  if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
1541    Anon = FieldDecl::Create(Context, OwningClass, Record->getLocation(),
1542                             /*IdentifierInfo=*/0,
1543                             Context.getTypeDeclType(Record),
1544                             DInfo,
1545                             /*BitWidth=*/0, /*Mutable=*/false);
1546    Anon->setAccess(AS_public);
1547    if (getLangOptions().CPlusPlus)
1548      FieldCollector->Add(cast<FieldDecl>(Anon));
1549  } else {
1550    VarDecl::StorageClass SC;
1551    switch (DS.getStorageClassSpec()) {
1552    default: assert(0 && "Unknown storage class!");
1553    case DeclSpec::SCS_unspecified:    SC = VarDecl::None; break;
1554    case DeclSpec::SCS_extern:         SC = VarDecl::Extern; break;
1555    case DeclSpec::SCS_static:         SC = VarDecl::Static; break;
1556    case DeclSpec::SCS_auto:           SC = VarDecl::Auto; break;
1557    case DeclSpec::SCS_register:       SC = VarDecl::Register; break;
1558    case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
1559    case DeclSpec::SCS_mutable:
1560      // mutable can only appear on non-static class members, so it's always
1561      // an error here
1562      Diag(Record->getLocation(), diag::err_mutable_nonmember);
1563      Invalid = true;
1564      SC = VarDecl::None;
1565      break;
1566    }
1567
1568    Anon = VarDecl::Create(Context, Owner, Record->getLocation(),
1569                           /*IdentifierInfo=*/0,
1570                           Context.getTypeDeclType(Record),
1571                           DInfo,
1572                           SC);
1573  }
1574  Anon->setImplicit();
1575
1576  // Add the anonymous struct/union object to the current
1577  // context. We'll be referencing this object when we refer to one of
1578  // its members.
1579  Owner->addDecl(Anon);
1580
1581  // Inject the members of the anonymous struct/union into the owning
1582  // context and into the identifier resolver chain for name lookup
1583  // purposes.
1584  if (InjectAnonymousStructOrUnionMembers(S, Owner, Record))
1585    Invalid = true;
1586
1587  // Mark this as an anonymous struct/union type. Note that we do not
1588  // do this until after we have already checked and injected the
1589  // members of this anonymous struct/union type, because otherwise
1590  // the members could be injected twice: once by DeclContext when it
1591  // builds its lookup table, and once by
1592  // InjectAnonymousStructOrUnionMembers.
1593  Record->setAnonymousStructOrUnion(true);
1594
1595  if (Invalid)
1596    Anon->setInvalidDecl();
1597
1598  return DeclPtrTy::make(Anon);
1599}
1600
1601
1602/// GetNameForDeclarator - Determine the full declaration name for the
1603/// given Declarator.
1604DeclarationName Sema::GetNameForDeclarator(Declarator &D) {
1605  switch (D.getKind()) {
1606  case Declarator::DK_Abstract:
1607    assert(D.getIdentifier() == 0 && "abstract declarators have no name");
1608    return DeclarationName();
1609
1610  case Declarator::DK_Normal:
1611    assert (D.getIdentifier() != 0 && "normal declarators have an identifier");
1612    return DeclarationName(D.getIdentifier());
1613
1614  case Declarator::DK_Constructor: {
1615    QualType Ty = GetTypeFromParser(D.getDeclaratorIdType());
1616    return Context.DeclarationNames.getCXXConstructorName(
1617                                                Context.getCanonicalType(Ty));
1618  }
1619
1620  case Declarator::DK_Destructor: {
1621    QualType Ty = GetTypeFromParser(D.getDeclaratorIdType());
1622    return Context.DeclarationNames.getCXXDestructorName(
1623                                                Context.getCanonicalType(Ty));
1624  }
1625
1626  case Declarator::DK_Conversion: {
1627    // FIXME: We'd like to keep the non-canonical type for diagnostics!
1628    QualType Ty = GetTypeFromParser(D.getDeclaratorIdType());
1629    return Context.DeclarationNames.getCXXConversionFunctionName(
1630                                                Context.getCanonicalType(Ty));
1631  }
1632
1633  case Declarator::DK_Operator:
1634    assert(D.getIdentifier() == 0 && "operator names have no identifier");
1635    return Context.DeclarationNames.getCXXOperatorName(
1636                                                D.getOverloadedOperator());
1637
1638  case Declarator::DK_TemplateId: {
1639    TemplateName Name
1640      = TemplateName::getFromVoidPointer(D.getTemplateId()->Template);
1641    if (TemplateDecl *Template = Name.getAsTemplateDecl())
1642      return Template->getDeclName();
1643    if (OverloadedFunctionDecl *Ovl = Name.getAsOverloadedFunctionDecl())
1644      return Ovl->getDeclName();
1645
1646    return DeclarationName();
1647  }
1648  }
1649
1650  assert(false && "Unknown name kind");
1651  return DeclarationName();
1652}
1653
1654/// isNearlyMatchingFunction - Determine whether the C++ functions
1655/// Declaration and Definition are "nearly" matching. This heuristic
1656/// is used to improve diagnostics in the case where an out-of-line
1657/// function definition doesn't match any declaration within
1658/// the class or namespace.
1659static bool isNearlyMatchingFunction(ASTContext &Context,
1660                                     FunctionDecl *Declaration,
1661                                     FunctionDecl *Definition) {
1662  if (Declaration->param_size() != Definition->param_size())
1663    return false;
1664  for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
1665    QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
1666    QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
1667
1668    DeclParamTy = Context.getCanonicalType(DeclParamTy.getNonReferenceType());
1669    DefParamTy = Context.getCanonicalType(DefParamTy.getNonReferenceType());
1670    if (DeclParamTy.getUnqualifiedType() != DefParamTy.getUnqualifiedType())
1671      return false;
1672  }
1673
1674  return true;
1675}
1676
1677Sema::DeclPtrTy
1678Sema::HandleDeclarator(Scope *S, Declarator &D,
1679                       MultiTemplateParamsArg TemplateParamLists,
1680                       bool IsFunctionDefinition) {
1681  DeclarationName Name = GetNameForDeclarator(D);
1682
1683  // All of these full declarators require an identifier.  If it doesn't have
1684  // one, the ParsedFreeStandingDeclSpec action should be used.
1685  if (!Name) {
1686    if (!D.isInvalidType())  // Reject this if we think it is valid.
1687      Diag(D.getDeclSpec().getSourceRange().getBegin(),
1688           diag::err_declarator_need_ident)
1689        << D.getDeclSpec().getSourceRange() << D.getSourceRange();
1690    return DeclPtrTy();
1691  }
1692
1693  // The scope passed in may not be a decl scope.  Zip up the scope tree until
1694  // we find one that is.
1695  while ((S->getFlags() & Scope::DeclScope) == 0 ||
1696         (S->getFlags() & Scope::TemplateParamScope) != 0)
1697    S = S->getParent();
1698
1699  // If this is an out-of-line definition of a member of a class template
1700  // or class template partial specialization, we may need to rebuild the
1701  // type specifier in the declarator. See RebuildTypeInCurrentInstantiation()
1702  // for more information.
1703  // FIXME: cope with decltype(expr) and typeof(expr) once the rebuilder can
1704  // handle expressions properly.
1705  DeclSpec &DS = const_cast<DeclSpec&>(D.getDeclSpec());
1706  if (D.getCXXScopeSpec().isSet() && !D.getCXXScopeSpec().isInvalid() &&
1707      isDependentScopeSpecifier(D.getCXXScopeSpec()) &&
1708      (DS.getTypeSpecType() == DeclSpec::TST_typename ||
1709       DS.getTypeSpecType() == DeclSpec::TST_typeofType ||
1710       DS.getTypeSpecType() == DeclSpec::TST_typeofExpr ||
1711       DS.getTypeSpecType() == DeclSpec::TST_decltype)) {
1712    if (DeclContext *DC = computeDeclContext(D.getCXXScopeSpec(), true)) {
1713      // FIXME: Preserve type source info.
1714      QualType T = GetTypeFromParser(DS.getTypeRep());
1715      EnterDeclaratorContext(S, DC);
1716      T = RebuildTypeInCurrentInstantiation(T, D.getIdentifierLoc(), Name);
1717      ExitDeclaratorContext(S);
1718      if (T.isNull())
1719        return DeclPtrTy();
1720      DS.UpdateTypeRep(T.getAsOpaquePtr());
1721    }
1722  }
1723
1724  DeclContext *DC;
1725  NamedDecl *PrevDecl;
1726  NamedDecl *New;
1727
1728  DeclaratorInfo *DInfo = 0;
1729  QualType R = GetTypeForDeclarator(D, S, &DInfo);
1730
1731  // See if this is a redefinition of a variable in the same scope.
1732  if (D.getCXXScopeSpec().isInvalid()) {
1733    DC = CurContext;
1734    PrevDecl = 0;
1735    D.setInvalidType();
1736  } else if (!D.getCXXScopeSpec().isSet()) {
1737    LookupNameKind NameKind = LookupOrdinaryName;
1738
1739    // If the declaration we're planning to build will be a function
1740    // or object with linkage, then look for another declaration with
1741    // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
1742    if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1743      /* Do nothing*/;
1744    else if (R->isFunctionType()) {
1745      if (CurContext->isFunctionOrMethod() ||
1746          D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1747        NameKind = LookupRedeclarationWithLinkage;
1748    } else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
1749      NameKind = LookupRedeclarationWithLinkage;
1750    else if (CurContext->getLookupContext()->isTranslationUnit() &&
1751             D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
1752      NameKind = LookupRedeclarationWithLinkage;
1753
1754    DC = CurContext;
1755    LookupResult R;
1756    LookupName(R, S, Name, NameKind, true,
1757               NameKind == LookupRedeclarationWithLinkage,
1758               D.getIdentifierLoc());
1759    PrevDecl = R.getAsSingleDecl(Context);
1760  } else { // Something like "int foo::x;"
1761    DC = computeDeclContext(D.getCXXScopeSpec(), true);
1762
1763    if (!DC) {
1764      // If we could not compute the declaration context, it's because the
1765      // declaration context is dependent but does not refer to a class,
1766      // class template, or class template partial specialization. Complain
1767      // and return early, to avoid the coming semantic disaster.
1768      Diag(D.getIdentifierLoc(),
1769           diag::err_template_qualified_declarator_no_match)
1770        << (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
1771        << D.getCXXScopeSpec().getRange();
1772      return DeclPtrTy();
1773    }
1774
1775    if (!DC->isDependentContext() &&
1776        RequireCompleteDeclContext(D.getCXXScopeSpec()))
1777      return DeclPtrTy();
1778
1779    LookupResult Res;
1780    LookupQualifiedName(Res, DC, Name, LookupOrdinaryName, true);
1781    PrevDecl = Res.getAsSingleDecl(Context);
1782
1783    // C++ 7.3.1.2p2:
1784    // Members (including explicit specializations of templates) of a named
1785    // namespace can also be defined outside that namespace by explicit
1786    // qualification of the name being defined, provided that the entity being
1787    // defined was already declared in the namespace and the definition appears
1788    // after the point of declaration in a namespace that encloses the
1789    // declarations namespace.
1790    //
1791    // Note that we only check the context at this point. We don't yet
1792    // have enough information to make sure that PrevDecl is actually
1793    // the declaration we want to match. For example, given:
1794    //
1795    //   class X {
1796    //     void f();
1797    //     void f(float);
1798    //   };
1799    //
1800    //   void X::f(int) { } // ill-formed
1801    //
1802    // In this case, PrevDecl will point to the overload set
1803    // containing the two f's declared in X, but neither of them
1804    // matches.
1805
1806    // First check whether we named the global scope.
1807    if (isa<TranslationUnitDecl>(DC)) {
1808      Diag(D.getIdentifierLoc(), diag::err_invalid_declarator_global_scope)
1809        << Name << D.getCXXScopeSpec().getRange();
1810    } else if (!CurContext->Encloses(DC)) {
1811      // The qualifying scope doesn't enclose the original declaration.
1812      // Emit diagnostic based on current scope.
1813      SourceLocation L = D.getIdentifierLoc();
1814      SourceRange R = D.getCXXScopeSpec().getRange();
1815      if (isa<FunctionDecl>(CurContext))
1816        Diag(L, diag::err_invalid_declarator_in_function) << Name << R;
1817      else
1818        Diag(L, diag::err_invalid_declarator_scope)
1819          << Name << cast<NamedDecl>(DC) << R;
1820      D.setInvalidType();
1821    }
1822  }
1823
1824  if (PrevDecl && PrevDecl->isTemplateParameter()) {
1825    // Maybe we will complain about the shadowed template parameter.
1826    if (!D.isInvalidType())
1827      if (DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl))
1828        D.setInvalidType();
1829
1830    // Just pretend that we didn't see the previous declaration.
1831    PrevDecl = 0;
1832  }
1833
1834  // In C++, the previous declaration we find might be a tag type
1835  // (class or enum). In this case, the new declaration will hide the
1836  // tag type. Note that this does does not apply if we're declaring a
1837  // typedef (C++ [dcl.typedef]p4).
1838  if (PrevDecl && PrevDecl->getIdentifierNamespace() == Decl::IDNS_Tag &&
1839      D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
1840    PrevDecl = 0;
1841
1842  bool Redeclaration = false;
1843  if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
1844    if (TemplateParamLists.size()) {
1845      Diag(D.getIdentifierLoc(), diag::err_template_typedef);
1846      return DeclPtrTy();
1847    }
1848
1849    New = ActOnTypedefDeclarator(S, D, DC, R, DInfo, PrevDecl, Redeclaration);
1850  } else if (R->isFunctionType()) {
1851    New = ActOnFunctionDeclarator(S, D, DC, R, DInfo, PrevDecl,
1852                                  move(TemplateParamLists),
1853                                  IsFunctionDefinition, Redeclaration);
1854  } else {
1855    New = ActOnVariableDeclarator(S, D, DC, R, DInfo, PrevDecl,
1856                                  move(TemplateParamLists),
1857                                  Redeclaration);
1858  }
1859
1860  if (New == 0)
1861    return DeclPtrTy();
1862
1863  // If this has an identifier and is not an invalid redeclaration or
1864  // function template specialization, add it to the scope stack.
1865  if (Name && !(Redeclaration && New->isInvalidDecl()) &&
1866      !(isa<FunctionDecl>(New) &&
1867        cast<FunctionDecl>(New)->isFunctionTemplateSpecialization()))
1868    PushOnScopeChains(New, S);
1869
1870  return DeclPtrTy::make(New);
1871}
1872
1873/// TryToFixInvalidVariablyModifiedType - Helper method to turn variable array
1874/// types into constant array types in certain situations which would otherwise
1875/// be errors (for GCC compatibility).
1876static QualType TryToFixInvalidVariablyModifiedType(QualType T,
1877                                                    ASTContext &Context,
1878                                                    bool &SizeIsNegative) {
1879  // This method tries to turn a variable array into a constant
1880  // array even when the size isn't an ICE.  This is necessary
1881  // for compatibility with code that depends on gcc's buggy
1882  // constant expression folding, like struct {char x[(int)(char*)2];}
1883  SizeIsNegative = false;
1884
1885  QualifierCollector Qs;
1886  const Type *Ty = Qs.strip(T);
1887
1888  if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
1889    QualType Pointee = PTy->getPointeeType();
1890    QualType FixedType =
1891        TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative);
1892    if (FixedType.isNull()) return FixedType;
1893    FixedType = Context.getPointerType(FixedType);
1894    return Qs.apply(FixedType);
1895  }
1896
1897  const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
1898  if (!VLATy)
1899    return QualType();
1900  // FIXME: We should probably handle this case
1901  if (VLATy->getElementType()->isVariablyModifiedType())
1902    return QualType();
1903
1904  Expr::EvalResult EvalResult;
1905  if (!VLATy->getSizeExpr() ||
1906      !VLATy->getSizeExpr()->Evaluate(EvalResult, Context) ||
1907      !EvalResult.Val.isInt())
1908    return QualType();
1909
1910  llvm::APSInt &Res = EvalResult.Val.getInt();
1911  if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
1912    // TODO: preserve the size expression in declarator info
1913    return Context.getConstantArrayType(VLATy->getElementType(),
1914                                        Res, ArrayType::Normal, 0);
1915  }
1916
1917  SizeIsNegative = true;
1918  return QualType();
1919}
1920
1921/// \brief Register the given locally-scoped external C declaration so
1922/// that it can be found later for redeclarations
1923void
1924Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
1925                                       Scope *S) {
1926  assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
1927         "Decl is not a locally-scoped decl!");
1928  // Note that we have a locally-scoped external with this name.
1929  LocallyScopedExternalDecls[ND->getDeclName()] = ND;
1930
1931  if (!PrevDecl)
1932    return;
1933
1934  // If there was a previous declaration of this variable, it may be
1935  // in our identifier chain. Update the identifier chain with the new
1936  // declaration.
1937  if (S && IdResolver.ReplaceDecl(PrevDecl, ND)) {
1938    // The previous declaration was found on the identifer resolver
1939    // chain, so remove it from its scope.
1940    while (S && !S->isDeclScope(DeclPtrTy::make(PrevDecl)))
1941      S = S->getParent();
1942
1943    if (S)
1944      S->RemoveDecl(DeclPtrTy::make(PrevDecl));
1945  }
1946}
1947
1948/// \brief Diagnose function specifiers on a declaration of an identifier that
1949/// does not identify a function.
1950void Sema::DiagnoseFunctionSpecifiers(Declarator& D) {
1951  // FIXME: We should probably indicate the identifier in question to avoid
1952  // confusion for constructs like "inline int a(), b;"
1953  if (D.getDeclSpec().isInlineSpecified())
1954    Diag(D.getDeclSpec().getInlineSpecLoc(),
1955         diag::err_inline_non_function);
1956
1957  if (D.getDeclSpec().isVirtualSpecified())
1958    Diag(D.getDeclSpec().getVirtualSpecLoc(),
1959         diag::err_virtual_non_function);
1960
1961  if (D.getDeclSpec().isExplicitSpecified())
1962    Diag(D.getDeclSpec().getExplicitSpecLoc(),
1963         diag::err_explicit_non_function);
1964}
1965
1966NamedDecl*
1967Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
1968                             QualType R,  DeclaratorInfo *DInfo,
1969                             NamedDecl* PrevDecl, bool &Redeclaration) {
1970  // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
1971  if (D.getCXXScopeSpec().isSet()) {
1972    Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
1973      << D.getCXXScopeSpec().getRange();
1974    D.setInvalidType();
1975    // Pretend we didn't see the scope specifier.
1976    DC = 0;
1977  }
1978
1979  if (getLangOptions().CPlusPlus) {
1980    // Check that there are no default arguments (C++ only).
1981    CheckExtraCXXDefaultArguments(D);
1982  }
1983
1984  DiagnoseFunctionSpecifiers(D);
1985
1986  if (D.getDeclSpec().isThreadSpecified())
1987    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
1988
1989  TypedefDecl *NewTD = ParseTypedefDecl(S, D, R);
1990  if (!NewTD) return 0;
1991
1992  if (D.isInvalidType())
1993    NewTD->setInvalidDecl();
1994
1995  // Handle attributes prior to checking for duplicates in MergeVarDecl
1996  ProcessDeclAttributes(S, NewTD, D);
1997  // Merge the decl with the existing one if appropriate. If the decl is
1998  // in an outer scope, it isn't the same thing.
1999  if (PrevDecl && isDeclInScope(PrevDecl, DC, S)) {
2000    Redeclaration = true;
2001    MergeTypeDefDecl(NewTD, PrevDecl);
2002  }
2003
2004  // C99 6.7.7p2: If a typedef name specifies a variably modified type
2005  // then it shall have block scope.
2006  QualType T = NewTD->getUnderlyingType();
2007  if (T->isVariablyModifiedType()) {
2008    CurFunctionNeedsScopeChecking = true;
2009
2010    if (S->getFnParent() == 0) {
2011      bool SizeIsNegative;
2012      QualType FixedTy =
2013          TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2014      if (!FixedTy.isNull()) {
2015        Diag(D.getIdentifierLoc(), diag::warn_illegal_constant_array_size);
2016        NewTD->setUnderlyingType(FixedTy);
2017      } else {
2018        if (SizeIsNegative)
2019          Diag(D.getIdentifierLoc(), diag::err_typecheck_negative_array_size);
2020        else if (T->isVariableArrayType())
2021          Diag(D.getIdentifierLoc(), diag::err_vla_decl_in_file_scope);
2022        else
2023          Diag(D.getIdentifierLoc(), diag::err_vm_decl_in_file_scope);
2024        NewTD->setInvalidDecl();
2025      }
2026    }
2027  }
2028
2029  // If this is the C FILE type, notify the AST context.
2030  if (IdentifierInfo *II = NewTD->getIdentifier())
2031    if (!NewTD->isInvalidDecl() &&
2032        NewTD->getDeclContext()->getLookupContext()->isTranslationUnit()) {
2033      if (II->isStr("FILE"))
2034        Context.setFILEDecl(NewTD);
2035      else if (II->isStr("jmp_buf"))
2036        Context.setjmp_bufDecl(NewTD);
2037      else if (II->isStr("sigjmp_buf"))
2038        Context.setsigjmp_bufDecl(NewTD);
2039    }
2040
2041  return NewTD;
2042}
2043
2044/// \brief Determines whether the given declaration is an out-of-scope
2045/// previous declaration.
2046///
2047/// This routine should be invoked when name lookup has found a
2048/// previous declaration (PrevDecl) that is not in the scope where a
2049/// new declaration by the same name is being introduced. If the new
2050/// declaration occurs in a local scope, previous declarations with
2051/// linkage may still be considered previous declarations (C99
2052/// 6.2.2p4-5, C++ [basic.link]p6).
2053///
2054/// \param PrevDecl the previous declaration found by name
2055/// lookup
2056///
2057/// \param DC the context in which the new declaration is being
2058/// declared.
2059///
2060/// \returns true if PrevDecl is an out-of-scope previous declaration
2061/// for a new delcaration with the same name.
2062static bool
2063isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
2064                                ASTContext &Context) {
2065  if (!PrevDecl)
2066    return 0;
2067
2068  // FIXME: PrevDecl could be an OverloadedFunctionDecl, in which
2069  // case we need to check each of the overloaded functions.
2070  if (!PrevDecl->hasLinkage())
2071    return false;
2072
2073  if (Context.getLangOptions().CPlusPlus) {
2074    // C++ [basic.link]p6:
2075    //   If there is a visible declaration of an entity with linkage
2076    //   having the same name and type, ignoring entities declared
2077    //   outside the innermost enclosing namespace scope, the block
2078    //   scope declaration declares that same entity and receives the
2079    //   linkage of the previous declaration.
2080    DeclContext *OuterContext = DC->getLookupContext();
2081    if (!OuterContext->isFunctionOrMethod())
2082      // This rule only applies to block-scope declarations.
2083      return false;
2084    else {
2085      DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
2086      if (PrevOuterContext->isRecord())
2087        // We found a member function: ignore it.
2088        return false;
2089      else {
2090        // Find the innermost enclosing namespace for the new and
2091        // previous declarations.
2092        while (!OuterContext->isFileContext())
2093          OuterContext = OuterContext->getParent();
2094        while (!PrevOuterContext->isFileContext())
2095          PrevOuterContext = PrevOuterContext->getParent();
2096
2097        // The previous declaration is in a different namespace, so it
2098        // isn't the same function.
2099        if (OuterContext->getPrimaryContext() !=
2100            PrevOuterContext->getPrimaryContext())
2101          return false;
2102      }
2103    }
2104  }
2105
2106  return true;
2107}
2108
2109NamedDecl*
2110Sema::ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2111                              QualType R, DeclaratorInfo *DInfo,
2112                              NamedDecl* PrevDecl,
2113                              MultiTemplateParamsArg TemplateParamLists,
2114                              bool &Redeclaration) {
2115  DeclarationName Name = GetNameForDeclarator(D);
2116
2117  // Check that there are no default arguments (C++ only).
2118  if (getLangOptions().CPlusPlus)
2119    CheckExtraCXXDefaultArguments(D);
2120
2121  VarDecl *NewVD;
2122  VarDecl::StorageClass SC;
2123  switch (D.getDeclSpec().getStorageClassSpec()) {
2124  default: assert(0 && "Unknown storage class!");
2125  case DeclSpec::SCS_unspecified:    SC = VarDecl::None; break;
2126  case DeclSpec::SCS_extern:         SC = VarDecl::Extern; break;
2127  case DeclSpec::SCS_static:         SC = VarDecl::Static; break;
2128  case DeclSpec::SCS_auto:           SC = VarDecl::Auto; break;
2129  case DeclSpec::SCS_register:       SC = VarDecl::Register; break;
2130  case DeclSpec::SCS_private_extern: SC = VarDecl::PrivateExtern; break;
2131  case DeclSpec::SCS_mutable:
2132    // mutable can only appear on non-static class members, so it's always
2133    // an error here
2134    Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
2135    D.setInvalidType();
2136    SC = VarDecl::None;
2137    break;
2138  }
2139
2140  IdentifierInfo *II = Name.getAsIdentifierInfo();
2141  if (!II) {
2142    Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
2143      << Name.getAsString();
2144    return 0;
2145  }
2146
2147  DiagnoseFunctionSpecifiers(D);
2148
2149  if (!DC->isRecord() && S->getFnParent() == 0) {
2150    // C99 6.9p2: The storage-class specifiers auto and register shall not
2151    // appear in the declaration specifiers in an external declaration.
2152    if (SC == VarDecl::Auto || SC == VarDecl::Register) {
2153
2154      // If this is a register variable with an asm label specified, then this
2155      // is a GNU extension.
2156      if (SC == VarDecl::Register && D.getAsmLabel())
2157        Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
2158      else
2159        Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
2160      D.setInvalidType();
2161    }
2162  }
2163  if (DC->isRecord() && !CurContext->isRecord()) {
2164    // This is an out-of-line definition of a static data member.
2165    if (SC == VarDecl::Static) {
2166      Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2167           diag::err_static_out_of_line)
2168        << CodeModificationHint::CreateRemoval(
2169                       SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
2170    } else if (SC == VarDecl::None)
2171      SC = VarDecl::Static;
2172  }
2173  if (SC == VarDecl::Static) {
2174    if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
2175      if (RD->isLocalClass())
2176        Diag(D.getIdentifierLoc(),
2177             diag::err_static_data_member_not_allowed_in_local_class)
2178          << Name << RD->getDeclName();
2179    }
2180  }
2181
2182  // Match up the template parameter lists with the scope specifier, then
2183  // determine whether we have a template or a template specialization.
2184  bool isExplicitSpecialization = false;
2185  if (TemplateParameterList *TemplateParams
2186        = MatchTemplateParametersToScopeSpecifier(
2187                                  D.getDeclSpec().getSourceRange().getBegin(),
2188                                                  D.getCXXScopeSpec(),
2189                        (TemplateParameterList**)TemplateParamLists.get(),
2190                                                   TemplateParamLists.size(),
2191                                                  isExplicitSpecialization)) {
2192    if (TemplateParams->size() > 0) {
2193      // There is no such thing as a variable template.
2194      Diag(D.getIdentifierLoc(), diag::err_template_variable)
2195        << II
2196        << SourceRange(TemplateParams->getTemplateLoc(),
2197                       TemplateParams->getRAngleLoc());
2198      return 0;
2199    } else {
2200      // There is an extraneous 'template<>' for this variable. Complain
2201      // about it, but allow the declaration of the variable.
2202      Diag(TemplateParams->getTemplateLoc(),
2203           diag::err_template_variable_noparams)
2204        << II
2205        << SourceRange(TemplateParams->getTemplateLoc(),
2206                       TemplateParams->getRAngleLoc());
2207
2208      isExplicitSpecialization = true;
2209    }
2210  }
2211
2212  NewVD = VarDecl::Create(Context, DC, D.getIdentifierLoc(),
2213                          II, R, DInfo, SC);
2214
2215  if (D.isInvalidType())
2216    NewVD->setInvalidDecl();
2217
2218  if (D.getDeclSpec().isThreadSpecified()) {
2219    if (NewVD->hasLocalStorage())
2220      Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_non_global);
2221    else if (!Context.Target.isTLSSupported())
2222      Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_thread_unsupported);
2223    else
2224      NewVD->setThreadSpecified(true);
2225  }
2226
2227  // Set the lexical context. If the declarator has a C++ scope specifier, the
2228  // lexical context will be different from the semantic context.
2229  NewVD->setLexicalDeclContext(CurContext);
2230
2231  // Handle attributes prior to checking for duplicates in MergeVarDecl
2232  ProcessDeclAttributes(S, NewVD, D);
2233
2234  // Handle GNU asm-label extension (encoded as an attribute).
2235  if (Expr *E = (Expr*) D.getAsmLabel()) {
2236    // The parser guarantees this is a string.
2237    StringLiteral *SE = cast<StringLiteral>(E);
2238    NewVD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
2239                                                        SE->getByteLength())));
2240  }
2241
2242  // If name lookup finds a previous declaration that is not in the
2243  // same scope as the new declaration, this may still be an
2244  // acceptable redeclaration.
2245  if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
2246      !(NewVD->hasLinkage() &&
2247        isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
2248    PrevDecl = 0;
2249
2250  // Merge the decl with the existing one if appropriate.
2251  if (PrevDecl) {
2252    if (isa<FieldDecl>(PrevDecl) && D.getCXXScopeSpec().isSet()) {
2253      // The user tried to define a non-static data member
2254      // out-of-line (C++ [dcl.meaning]p1).
2255      Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
2256        << D.getCXXScopeSpec().getRange();
2257      PrevDecl = 0;
2258      NewVD->setInvalidDecl();
2259    }
2260  } else if (D.getCXXScopeSpec().isSet()) {
2261    // No previous declaration in the qualifying scope.
2262    Diag(D.getIdentifierLoc(), diag::err_no_member)
2263      << Name << computeDeclContext(D.getCXXScopeSpec(), true)
2264      << D.getCXXScopeSpec().getRange();
2265    NewVD->setInvalidDecl();
2266  }
2267
2268  CheckVariableDeclaration(NewVD, PrevDecl, Redeclaration);
2269
2270  // This is an explicit specialization of a static data member. Check it.
2271  if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
2272      CheckMemberSpecialization(NewVD, PrevDecl))
2273    NewVD->setInvalidDecl();
2274
2275  // attributes declared post-definition are currently ignored
2276  if (PrevDecl) {
2277    const VarDecl *Def = 0, *PrevVD = dyn_cast<VarDecl>(PrevDecl);
2278    if (PrevVD->getDefinition(Def) && D.hasAttributes()) {
2279      Diag(NewVD->getLocation(), diag::warn_attribute_precede_definition);
2280      Diag(Def->getLocation(), diag::note_previous_definition);
2281    }
2282  }
2283
2284  // If this is a locally-scoped extern C variable, update the map of
2285  // such variables.
2286  if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
2287      !NewVD->isInvalidDecl())
2288    RegisterLocallyScopedExternCDecl(NewVD, PrevDecl, S);
2289
2290  return NewVD;
2291}
2292
2293/// \brief Perform semantic checking on a newly-created variable
2294/// declaration.
2295///
2296/// This routine performs all of the type-checking required for a
2297/// variable declaration once it has been built. It is used both to
2298/// check variables after they have been parsed and their declarators
2299/// have been translated into a declaration, and to check variables
2300/// that have been instantiated from a template.
2301///
2302/// Sets NewVD->isInvalidDecl() if an error was encountered.
2303void Sema::CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
2304                                    bool &Redeclaration) {
2305  // If the decl is already known invalid, don't check it.
2306  if (NewVD->isInvalidDecl())
2307    return;
2308
2309  QualType T = NewVD->getType();
2310
2311  if (T->isObjCInterfaceType()) {
2312    Diag(NewVD->getLocation(), diag::err_statically_allocated_object);
2313    return NewVD->setInvalidDecl();
2314  }
2315
2316  // The variable can not have an abstract class type.
2317  if (RequireNonAbstractType(NewVD->getLocation(), T,
2318                             diag::err_abstract_type_in_decl,
2319                             AbstractVariableType))
2320    return NewVD->setInvalidDecl();
2321
2322  // Emit an error if an address space was applied to decl with local storage.
2323  // This includes arrays of objects with address space qualifiers, but not
2324  // automatic variables that point to other address spaces.
2325  // ISO/IEC TR 18037 S5.1.2
2326  if (NewVD->hasLocalStorage() && (T.getAddressSpace() != 0)) {
2327    Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
2328    return NewVD->setInvalidDecl();
2329  }
2330
2331  if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
2332      && !NewVD->hasAttr<BlocksAttr>())
2333    Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
2334
2335  bool isVM = T->isVariablyModifiedType();
2336  if (isVM || NewVD->hasAttr<CleanupAttr>() ||
2337      NewVD->hasAttr<BlocksAttr>())
2338    CurFunctionNeedsScopeChecking = true;
2339
2340  if ((isVM && NewVD->hasLinkage()) ||
2341      (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
2342    bool SizeIsNegative;
2343    QualType FixedTy =
2344        TryToFixInvalidVariablyModifiedType(T, Context, SizeIsNegative);
2345
2346    if (FixedTy.isNull() && T->isVariableArrayType()) {
2347      const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
2348      // FIXME: This won't give the correct result for
2349      // int a[10][n];
2350      SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
2351
2352      if (NewVD->isFileVarDecl())
2353        Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
2354        << SizeRange;
2355      else if (NewVD->getStorageClass() == VarDecl::Static)
2356        Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
2357        << SizeRange;
2358      else
2359        Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
2360        << SizeRange;
2361      return NewVD->setInvalidDecl();
2362    }
2363
2364    if (FixedTy.isNull()) {
2365      if (NewVD->isFileVarDecl())
2366        Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
2367      else
2368        Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
2369      return NewVD->setInvalidDecl();
2370    }
2371
2372    Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
2373    NewVD->setType(FixedTy);
2374  }
2375
2376  if (!PrevDecl && NewVD->isExternC()) {
2377    // Since we did not find anything by this name and we're declaring
2378    // an extern "C" variable, look for a non-visible extern "C"
2379    // declaration with the same name.
2380    llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2381      = LocallyScopedExternalDecls.find(NewVD->getDeclName());
2382    if (Pos != LocallyScopedExternalDecls.end())
2383      PrevDecl = Pos->second;
2384  }
2385
2386  if (T->isVoidType() && !NewVD->hasExternalStorage()) {
2387    Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
2388      << T;
2389    return NewVD->setInvalidDecl();
2390  }
2391
2392  if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
2393    Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
2394    return NewVD->setInvalidDecl();
2395  }
2396
2397  if (isVM && NewVD->hasAttr<BlocksAttr>()) {
2398    Diag(NewVD->getLocation(), diag::err_block_on_vm);
2399    return NewVD->setInvalidDecl();
2400  }
2401
2402  if (PrevDecl) {
2403    Redeclaration = true;
2404    MergeVarDecl(NewVD, PrevDecl);
2405  }
2406}
2407
2408static bool isUsingDecl(Decl *D) {
2409  return isa<UsingDecl>(D) || isa<UnresolvedUsingDecl>(D);
2410}
2411
2412/// \brief Data used with FindOverriddenMethod
2413struct FindOverriddenMethodData {
2414  Sema *S;
2415  CXXMethodDecl *Method;
2416};
2417
2418/// \brief Member lookup function that determines whether a given C++
2419/// method overrides a method in a base class, to be used with
2420/// CXXRecordDecl::lookupInBases().
2421static bool FindOverriddenMethod(CXXBaseSpecifier *Specifier,
2422                                 CXXBasePath &Path,
2423                                 void *UserData) {
2424  RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
2425
2426  FindOverriddenMethodData *Data
2427    = reinterpret_cast<FindOverriddenMethodData*>(UserData);
2428  for (Path.Decls = BaseRecord->lookup(Data->Method->getDeclName());
2429       Path.Decls.first != Path.Decls.second;
2430       ++Path.Decls.first) {
2431    if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(*Path.Decls.first)) {
2432      OverloadedFunctionDecl::function_iterator MatchedDecl;
2433      if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, MatchedDecl))
2434        return true;
2435    }
2436  }
2437
2438  return false;
2439}
2440
2441NamedDecl*
2442Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
2443                              QualType R, DeclaratorInfo *DInfo,
2444                              NamedDecl* PrevDecl,
2445                              MultiTemplateParamsArg TemplateParamLists,
2446                              bool IsFunctionDefinition, bool &Redeclaration) {
2447  assert(R.getTypePtr()->isFunctionType());
2448
2449  DeclarationName Name = GetNameForDeclarator(D);
2450  FunctionDecl::StorageClass SC = FunctionDecl::None;
2451  switch (D.getDeclSpec().getStorageClassSpec()) {
2452  default: assert(0 && "Unknown storage class!");
2453  case DeclSpec::SCS_auto:
2454  case DeclSpec::SCS_register:
2455  case DeclSpec::SCS_mutable:
2456    Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2457         diag::err_typecheck_sclass_func);
2458    D.setInvalidType();
2459    break;
2460  case DeclSpec::SCS_unspecified: SC = FunctionDecl::None; break;
2461  case DeclSpec::SCS_extern:      SC = FunctionDecl::Extern; break;
2462  case DeclSpec::SCS_static: {
2463    if (CurContext->getLookupContext()->isFunctionOrMethod()) {
2464      // C99 6.7.1p5:
2465      //   The declaration of an identifier for a function that has
2466      //   block scope shall have no explicit storage-class specifier
2467      //   other than extern
2468      // See also (C++ [dcl.stc]p4).
2469      Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2470           diag::err_static_block_func);
2471      SC = FunctionDecl::None;
2472    } else
2473      SC = FunctionDecl::Static;
2474    break;
2475  }
2476  case DeclSpec::SCS_private_extern: SC = FunctionDecl::PrivateExtern;break;
2477  }
2478
2479  if (D.getDeclSpec().isThreadSpecified())
2480    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
2481
2482  bool isFriend = D.getDeclSpec().isFriendSpecified();
2483  bool isInline = D.getDeclSpec().isInlineSpecified();
2484  bool isVirtual = D.getDeclSpec().isVirtualSpecified();
2485  bool isExplicit = D.getDeclSpec().isExplicitSpecified();
2486
2487  // Check that the return type is not an abstract class type.
2488  // For record types, this is done by the AbstractClassUsageDiagnoser once
2489  // the class has been completely parsed.
2490  if (!DC->isRecord() &&
2491      RequireNonAbstractType(D.getIdentifierLoc(),
2492                             R->getAs<FunctionType>()->getResultType(),
2493                             diag::err_abstract_type_in_decl,
2494                             AbstractReturnType))
2495    D.setInvalidType();
2496
2497  // Do not allow returning a objc interface by-value.
2498  if (R->getAs<FunctionType>()->getResultType()->isObjCInterfaceType()) {
2499    Diag(D.getIdentifierLoc(),
2500         diag::err_object_cannot_be_passed_returned_by_value) << 0
2501      << R->getAs<FunctionType>()->getResultType();
2502    D.setInvalidType();
2503  }
2504
2505  bool isVirtualOkay = false;
2506  FunctionDecl *NewFD;
2507
2508  if (isFriend) {
2509    // DC is the namespace in which the function is being declared.
2510    assert((DC->isFileContext() || PrevDecl) && "previously-undeclared "
2511           "friend function being created in a non-namespace context");
2512
2513    // C++ [class.friend]p5
2514    //   A function can be defined in a friend declaration of a
2515    //   class . . . . Such a function is implicitly inline.
2516    isInline |= IsFunctionDefinition;
2517  }
2518
2519  if (D.getKind() == Declarator::DK_Constructor) {
2520    // This is a C++ constructor declaration.
2521    assert(DC->isRecord() &&
2522           "Constructors can only be declared in a member context");
2523
2524    R = CheckConstructorDeclarator(D, R, SC);
2525
2526    // Create the new declaration
2527    NewFD = CXXConstructorDecl::Create(Context,
2528                                       cast<CXXRecordDecl>(DC),
2529                                       D.getIdentifierLoc(), Name, R, DInfo,
2530                                       isExplicit, isInline,
2531                                       /*isImplicitlyDeclared=*/false);
2532  } else if (D.getKind() == Declarator::DK_Destructor) {
2533    // This is a C++ destructor declaration.
2534    if (DC->isRecord()) {
2535      R = CheckDestructorDeclarator(D, SC);
2536
2537      NewFD = CXXDestructorDecl::Create(Context,
2538                                        cast<CXXRecordDecl>(DC),
2539                                        D.getIdentifierLoc(), Name, R,
2540                                        isInline,
2541                                        /*isImplicitlyDeclared=*/false);
2542
2543      isVirtualOkay = true;
2544    } else {
2545      Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
2546
2547      // Create a FunctionDecl to satisfy the function definition parsing
2548      // code path.
2549      NewFD = FunctionDecl::Create(Context, DC, D.getIdentifierLoc(),
2550                                   Name, R, DInfo, SC, isInline,
2551                                   /*hasPrototype=*/true);
2552      D.setInvalidType();
2553    }
2554  } else if (D.getKind() == Declarator::DK_Conversion) {
2555    if (!DC->isRecord()) {
2556      Diag(D.getIdentifierLoc(),
2557           diag::err_conv_function_not_member);
2558      return 0;
2559    }
2560
2561    CheckConversionDeclarator(D, R, SC);
2562    NewFD = CXXConversionDecl::Create(Context, cast<CXXRecordDecl>(DC),
2563                                      D.getIdentifierLoc(), Name, R, DInfo,
2564                                      isInline, isExplicit);
2565
2566    isVirtualOkay = true;
2567  } else if (DC->isRecord()) {
2568    // If the of the function is the same as the name of the record, then this
2569    // must be an invalid constructor that has a return type.
2570    // (The parser checks for a return type and makes the declarator a
2571    // constructor if it has no return type).
2572    // must have an invalid constructor that has a return type
2573    if (Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
2574      Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
2575        << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
2576        << SourceRange(D.getIdentifierLoc());
2577      return 0;
2578    }
2579
2580    // This is a C++ method declaration.
2581    NewFD = CXXMethodDecl::Create(Context, cast<CXXRecordDecl>(DC),
2582                                  D.getIdentifierLoc(), Name, R, DInfo,
2583                                  (SC == FunctionDecl::Static), isInline);
2584
2585    isVirtualOkay = (SC != FunctionDecl::Static);
2586  } else {
2587    // Determine whether the function was written with a
2588    // prototype. This true when:
2589    //   - we're in C++ (where every function has a prototype),
2590    //   - there is a prototype in the declarator, or
2591    //   - the type R of the function is some kind of typedef or other reference
2592    //     to a type name (which eventually refers to a function type).
2593    bool HasPrototype =
2594       getLangOptions().CPlusPlus ||
2595       (D.getNumTypeObjects() && D.getTypeObject(0).Fun.hasPrototype) ||
2596       (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
2597
2598    NewFD = FunctionDecl::Create(Context, DC,
2599                                 D.getIdentifierLoc(),
2600                                 Name, R, DInfo, SC, isInline, HasPrototype);
2601  }
2602
2603  if (D.isInvalidType())
2604    NewFD->setInvalidDecl();
2605
2606  // Set the lexical context. If the declarator has a C++
2607  // scope specifier, or is the object of a friend declaration, the
2608  // lexical context will be different from the semantic context.
2609  NewFD->setLexicalDeclContext(CurContext);
2610
2611  // Match up the template parameter lists with the scope specifier, then
2612  // determine whether we have a template or a template specialization.
2613  FunctionTemplateDecl *FunctionTemplate = 0;
2614  bool isExplicitSpecialization = false;
2615  bool isFunctionTemplateSpecialization = false;
2616  if (TemplateParameterList *TemplateParams
2617        = MatchTemplateParametersToScopeSpecifier(
2618                                  D.getDeclSpec().getSourceRange().getBegin(),
2619                                  D.getCXXScopeSpec(),
2620                           (TemplateParameterList**)TemplateParamLists.get(),
2621                                                  TemplateParamLists.size(),
2622                                                  isExplicitSpecialization)) {
2623    if (TemplateParams->size() > 0) {
2624      // This is a function template
2625
2626      // Check that we can declare a template here.
2627      if (CheckTemplateDeclScope(S, TemplateParams))
2628        return 0;
2629
2630      FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
2631                                                      NewFD->getLocation(),
2632                                                      Name, TemplateParams,
2633                                                      NewFD);
2634      FunctionTemplate->setLexicalDeclContext(CurContext);
2635      NewFD->setDescribedFunctionTemplate(FunctionTemplate);
2636    } else {
2637      // This is a function template specialization.
2638      isFunctionTemplateSpecialization = true;
2639    }
2640
2641    // FIXME: Free this memory properly.
2642    TemplateParamLists.release();
2643  }
2644
2645  // C++ [dcl.fct.spec]p5:
2646  //   The virtual specifier shall only be used in declarations of
2647  //   nonstatic class member functions that appear within a
2648  //   member-specification of a class declaration; see 10.3.
2649  //
2650  if (isVirtual && !NewFD->isInvalidDecl()) {
2651    if (!isVirtualOkay) {
2652       Diag(D.getDeclSpec().getVirtualSpecLoc(),
2653           diag::err_virtual_non_function);
2654    } else if (!CurContext->isRecord()) {
2655      // 'virtual' was specified outside of the class.
2656      Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class)
2657        << CodeModificationHint::CreateRemoval(
2658                             SourceRange(D.getDeclSpec().getVirtualSpecLoc()));
2659    } else {
2660      // Okay: Add virtual to the method.
2661      cast<CXXMethodDecl>(NewFD)->setVirtualAsWritten(true);
2662      CXXRecordDecl *CurClass = cast<CXXRecordDecl>(DC);
2663      CurClass->setAggregate(false);
2664      CurClass->setPOD(false);
2665      CurClass->setEmpty(false);
2666      CurClass->setPolymorphic(true);
2667      CurClass->setHasTrivialConstructor(false);
2668      CurClass->setHasTrivialCopyConstructor(false);
2669      CurClass->setHasTrivialCopyAssignment(false);
2670    }
2671  }
2672
2673  if (isFriend) {
2674    if (FunctionTemplate) {
2675      FunctionTemplate->setObjectOfFriendDecl(
2676                                   /* PreviouslyDeclared= */ PrevDecl != NULL);
2677      FunctionTemplate->setAccess(AS_public);
2678    }
2679    else
2680      NewFD->setObjectOfFriendDecl(/* PreviouslyDeclared= */ PrevDecl != NULL);
2681
2682    NewFD->setAccess(AS_public);
2683  }
2684
2685
2686  if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD)) {
2687    // Look for virtual methods in base classes that this method might override.
2688    CXXBasePaths Paths;
2689    FindOverriddenMethodData Data;
2690    Data.Method = NewMD;
2691    Data.S = this;
2692    if (cast<CXXRecordDecl>(DC)->lookupInBases(&FindOverriddenMethod, &Data,
2693                                                Paths)) {
2694      for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
2695           E = Paths.found_decls_end(); I != E; ++I) {
2696        if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
2697          if (!CheckOverridingFunctionReturnType(NewMD, OldMD) &&
2698              !CheckOverridingFunctionExceptionSpec(NewMD, OldMD))
2699            NewMD->addOverriddenMethod(OldMD);
2700        }
2701      }
2702    }
2703  }
2704
2705  if (SC == FunctionDecl::Static && isa<CXXMethodDecl>(NewFD) &&
2706      !CurContext->isRecord()) {
2707    // C++ [class.static]p1:
2708    //   A data or function member of a class may be declared static
2709    //   in a class definition, in which case it is a static member of
2710    //   the class.
2711
2712    // Complain about the 'static' specifier if it's on an out-of-line
2713    // member function definition.
2714    Diag(D.getDeclSpec().getStorageClassSpecLoc(),
2715         diag::err_static_out_of_line)
2716      << CodeModificationHint::CreateRemoval(
2717                      SourceRange(D.getDeclSpec().getStorageClassSpecLoc()));
2718  }
2719
2720  // Handle GNU asm-label extension (encoded as an attribute).
2721  if (Expr *E = (Expr*) D.getAsmLabel()) {
2722    // The parser guarantees this is a string.
2723    StringLiteral *SE = cast<StringLiteral>(E);
2724    NewFD->addAttr(::new (Context) AsmLabelAttr(std::string(SE->getStrData(),
2725                                                        SE->getByteLength())));
2726  }
2727
2728  // Copy the parameter declarations from the declarator D to the function
2729  // declaration NewFD, if they are available.  First scavenge them into Params.
2730  llvm::SmallVector<ParmVarDecl*, 16> Params;
2731  if (D.getNumTypeObjects() > 0) {
2732    DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
2733
2734    // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
2735    // function that takes no arguments, not a function that takes a
2736    // single void argument.
2737    // We let through "const void" here because Sema::GetTypeForDeclarator
2738    // already checks for that case.
2739    if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
2740        FTI.ArgInfo[0].Param &&
2741        FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType()) {
2742      // Empty arg list, don't push any params.
2743      ParmVarDecl *Param = FTI.ArgInfo[0].Param.getAs<ParmVarDecl>();
2744
2745      // In C++, the empty parameter-type-list must be spelled "void"; a
2746      // typedef of void is not permitted.
2747      if (getLangOptions().CPlusPlus &&
2748          Param->getType().getUnqualifiedType() != Context.VoidTy)
2749        Diag(Param->getLocation(), diag::err_param_typedef_of_void);
2750      // FIXME: Leaks decl?
2751    } else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
2752      for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
2753        ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>();
2754        assert(Param->getDeclContext() != NewFD && "Was set before ?");
2755        Param->setDeclContext(NewFD);
2756        Params.push_back(Param);
2757      }
2758    }
2759
2760  } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
2761    // When we're declaring a function with a typedef, typeof, etc as in the
2762    // following example, we'll need to synthesize (unnamed)
2763    // parameters for use in the declaration.
2764    //
2765    // @code
2766    // typedef void fn(int);
2767    // fn f;
2768    // @endcode
2769
2770    // Synthesize a parameter for each argument type.
2771    for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
2772         AE = FT->arg_type_end(); AI != AE; ++AI) {
2773      ParmVarDecl *Param = ParmVarDecl::Create(Context, DC,
2774                                               SourceLocation(), 0,
2775                                               *AI, /*DInfo=*/0,
2776                                               VarDecl::None, 0);
2777      Param->setImplicit();
2778      Params.push_back(Param);
2779    }
2780  } else {
2781    assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
2782           "Should not need args for typedef of non-prototype fn");
2783  }
2784  // Finally, we know we have the right number of parameters, install them.
2785  NewFD->setParams(Context, Params.data(), Params.size());
2786
2787  // If name lookup finds a previous declaration that is not in the
2788  // same scope as the new declaration, this may still be an
2789  // acceptable redeclaration.
2790  if (PrevDecl && !isDeclInScope(PrevDecl, DC, S) &&
2791      !(NewFD->hasLinkage() &&
2792        isOutOfScopePreviousDeclaration(PrevDecl, DC, Context)))
2793    PrevDecl = 0;
2794
2795  // If the declarator is a template-id, translate the parser's template
2796  // argument list into our AST format.
2797  bool HasExplicitTemplateArgs = false;
2798  llvm::SmallVector<TemplateArgument, 16> TemplateArgs;
2799  SourceLocation LAngleLoc, RAngleLoc;
2800  if (D.getKind() == Declarator::DK_TemplateId) {
2801    TemplateIdAnnotation *TemplateId = D.getTemplateId();
2802    ASTTemplateArgsPtr TemplateArgsPtr(*this,
2803                                       TemplateId->getTemplateArgs(),
2804                                       TemplateId->getTemplateArgIsType(),
2805                                       TemplateId->NumArgs);
2806    translateTemplateArguments(TemplateArgsPtr,
2807                               TemplateId->getTemplateArgLocations(),
2808                               TemplateArgs);
2809    TemplateArgsPtr.release();
2810
2811    HasExplicitTemplateArgs = true;
2812    LAngleLoc = TemplateId->LAngleLoc;
2813    RAngleLoc = TemplateId->RAngleLoc;
2814
2815    if (FunctionTemplate) {
2816      // FIXME: Diagnose function template with explicit template
2817      // arguments.
2818      HasExplicitTemplateArgs = false;
2819    } else if (!isFunctionTemplateSpecialization &&
2820               !D.getDeclSpec().isFriendSpecified()) {
2821      // We have encountered something that the user meant to be a
2822      // specialization (because it has explicitly-specified template
2823      // arguments) but that was not introduced with a "template<>" (or had
2824      // too few of them).
2825      Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
2826        << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
2827        << CodeModificationHint::CreateInsertion(
2828                                   D.getDeclSpec().getSourceRange().getBegin(),
2829                                                 "template<> ");
2830      isFunctionTemplateSpecialization = true;
2831    }
2832  }
2833
2834  if (isFunctionTemplateSpecialization) {
2835      if (CheckFunctionTemplateSpecialization(NewFD, HasExplicitTemplateArgs,
2836                                              LAngleLoc, TemplateArgs.data(),
2837                                              TemplateArgs.size(), RAngleLoc,
2838                                              PrevDecl))
2839        NewFD->setInvalidDecl();
2840  } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD) &&
2841             CheckMemberSpecialization(NewFD, PrevDecl))
2842    NewFD->setInvalidDecl();
2843
2844  // Perform semantic checking on the function declaration.
2845  bool OverloadableAttrRequired = false; // FIXME: HACK!
2846  CheckFunctionDeclaration(NewFD, PrevDecl, isExplicitSpecialization,
2847                           Redeclaration, /*FIXME:*/OverloadableAttrRequired);
2848
2849  if (D.getCXXScopeSpec().isSet() && !NewFD->isInvalidDecl()) {
2850    // An out-of-line member function declaration must also be a
2851    // definition (C++ [dcl.meaning]p1).
2852    // Note that this is not the case for explicit specializations of
2853    // function templates or member functions of class templates, per
2854    // C++ [temp.expl.spec]p2.
2855    if (!IsFunctionDefinition && !isFriend &&
2856        !isFunctionTemplateSpecialization && !isExplicitSpecialization) {
2857      Diag(NewFD->getLocation(), diag::err_out_of_line_declaration)
2858        << D.getCXXScopeSpec().getRange();
2859      NewFD->setInvalidDecl();
2860    } else if (!Redeclaration && (!PrevDecl || !isUsingDecl(PrevDecl))) {
2861      // The user tried to provide an out-of-line definition for a
2862      // function that is a member of a class or namespace, but there
2863      // was no such member function declared (C++ [class.mfct]p2,
2864      // C++ [namespace.memdef]p2). For example:
2865      //
2866      // class X {
2867      //   void f() const;
2868      // };
2869      //
2870      // void X::f() { } // ill-formed
2871      //
2872      // Complain about this problem, and attempt to suggest close
2873      // matches (e.g., those that differ only in cv-qualifiers and
2874      // whether the parameter types are references).
2875      Diag(D.getIdentifierLoc(), diag::err_member_def_does_not_match)
2876        << Name << DC << D.getCXXScopeSpec().getRange();
2877      NewFD->setInvalidDecl();
2878
2879      LookupResult Prev;
2880      LookupQualifiedName(Prev, DC, Name, LookupOrdinaryName, true);
2881      assert(!Prev.isAmbiguous() &&
2882             "Cannot have an ambiguity in previous-declaration lookup");
2883      for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
2884           Func != FuncEnd; ++Func) {
2885        if (isa<FunctionDecl>(*Func) &&
2886            isNearlyMatchingFunction(Context, cast<FunctionDecl>(*Func), NewFD))
2887          Diag((*Func)->getLocation(), diag::note_member_def_close_match);
2888      }
2889
2890      PrevDecl = 0;
2891    }
2892  }
2893
2894  // Handle attributes. We need to have merged decls when handling attributes
2895  // (for example to check for conflicts, etc).
2896  // FIXME: This needs to happen before we merge declarations. Then,
2897  // let attribute merging cope with attribute conflicts.
2898  ProcessDeclAttributes(S, NewFD, D);
2899
2900  // attributes declared post-definition are currently ignored
2901  if (Redeclaration && PrevDecl) {
2902    const FunctionDecl *Def, *PrevFD = dyn_cast<FunctionDecl>(PrevDecl);
2903    if (PrevFD && PrevFD->getBody(Def) && D.hasAttributes()) {
2904      Diag(NewFD->getLocation(), diag::warn_attribute_precede_definition);
2905      Diag(Def->getLocation(), diag::note_previous_definition);
2906    }
2907  }
2908
2909  AddKnownFunctionAttributes(NewFD);
2910
2911  if (OverloadableAttrRequired && !NewFD->getAttr<OverloadableAttr>()) {
2912    // If a function name is overloadable in C, then every function
2913    // with that name must be marked "overloadable".
2914    Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
2915      << Redeclaration << NewFD;
2916    if (PrevDecl)
2917      Diag(PrevDecl->getLocation(),
2918           diag::note_attribute_overloadable_prev_overload);
2919    NewFD->addAttr(::new (Context) OverloadableAttr());
2920  }
2921
2922  // If this is a locally-scoped extern C function, update the
2923  // map of such names.
2924  if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
2925      && !NewFD->isInvalidDecl())
2926    RegisterLocallyScopedExternCDecl(NewFD, PrevDecl, S);
2927
2928  // Set this FunctionDecl's range up to the right paren.
2929  NewFD->setLocEnd(D.getSourceRange().getEnd());
2930
2931  if (FunctionTemplate && NewFD->isInvalidDecl())
2932    FunctionTemplate->setInvalidDecl();
2933
2934  if (FunctionTemplate)
2935    return FunctionTemplate;
2936
2937  return NewFD;
2938}
2939
2940/// \brief Perform semantic checking of a new function declaration.
2941///
2942/// Performs semantic analysis of the new function declaration
2943/// NewFD. This routine performs all semantic checking that does not
2944/// require the actual declarator involved in the declaration, and is
2945/// used both for the declaration of functions as they are parsed
2946/// (called via ActOnDeclarator) and for the declaration of functions
2947/// that have been instantiated via C++ template instantiation (called
2948/// via InstantiateDecl).
2949///
2950/// \param IsExplicitSpecialiation whether this new function declaration is
2951/// an explicit specialization of the previous declaration.
2952///
2953/// This sets NewFD->isInvalidDecl() to true if there was an error.
2954void Sema::CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
2955                                    bool IsExplicitSpecialization,
2956                                    bool &Redeclaration,
2957                                    bool &OverloadableAttrRequired) {
2958  // If NewFD is already known erroneous, don't do any of this checking.
2959  if (NewFD->isInvalidDecl())
2960    return;
2961
2962  if (NewFD->getResultType()->isVariablyModifiedType()) {
2963    // Functions returning a variably modified type violate C99 6.7.5.2p2
2964    // because all functions have linkage.
2965    Diag(NewFD->getLocation(), diag::err_vm_func_decl);
2966    return NewFD->setInvalidDecl();
2967  }
2968
2969  if (NewFD->isMain())
2970    CheckMain(NewFD);
2971
2972  // Check for a previous declaration of this name.
2973  if (!PrevDecl && NewFD->isExternC()) {
2974    // Since we did not find anything by this name and we're declaring
2975    // an extern "C" function, look for a non-visible extern "C"
2976    // declaration with the same name.
2977    llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
2978      = LocallyScopedExternalDecls.find(NewFD->getDeclName());
2979    if (Pos != LocallyScopedExternalDecls.end())
2980      PrevDecl = Pos->second;
2981  }
2982
2983  // Merge or overload the declaration with an existing declaration of
2984  // the same name, if appropriate.
2985  if (PrevDecl) {
2986    // Determine whether NewFD is an overload of PrevDecl or
2987    // a declaration that requires merging. If it's an overload,
2988    // there's no more work to do here; we'll just add the new
2989    // function to the scope.
2990    OverloadedFunctionDecl::function_iterator MatchedDecl;
2991
2992    if (!getLangOptions().CPlusPlus &&
2993        AllowOverloadingOfFunction(PrevDecl, Context)) {
2994      OverloadableAttrRequired = true;
2995
2996      // Functions marked "overloadable" must have a prototype (that
2997      // we can't get through declaration merging).
2998      if (!NewFD->getType()->getAs<FunctionProtoType>()) {
2999        Diag(NewFD->getLocation(), diag::err_attribute_overloadable_no_prototype)
3000          << NewFD;
3001        Redeclaration = true;
3002
3003        // Turn this into a variadic function with no parameters.
3004        QualType R = Context.getFunctionType(
3005                       NewFD->getType()->getAs<FunctionType>()->getResultType(),
3006                       0, 0, true, 0);
3007        NewFD->setType(R);
3008        return NewFD->setInvalidDecl();
3009      }
3010    }
3011
3012    if (PrevDecl &&
3013        (!AllowOverloadingOfFunction(PrevDecl, Context) ||
3014         !IsOverload(NewFD, PrevDecl, MatchedDecl)) && !isUsingDecl(PrevDecl)) {
3015      Redeclaration = true;
3016      Decl *OldDecl = PrevDecl;
3017
3018      // If PrevDecl was an overloaded function, extract the
3019      // FunctionDecl that matched.
3020      if (isa<OverloadedFunctionDecl>(PrevDecl))
3021        OldDecl = *MatchedDecl;
3022
3023      // NewFD and OldDecl represent declarations that need to be
3024      // merged.
3025      if (MergeFunctionDecl(NewFD, OldDecl))
3026        return NewFD->setInvalidDecl();
3027
3028      if (FunctionTemplateDecl *OldTemplateDecl
3029                                    = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
3030        NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
3031        FunctionTemplateDecl *NewTemplateDecl
3032          = NewFD->getDescribedFunctionTemplate();
3033        assert(NewTemplateDecl && "Template/non-template mismatch");
3034        if (CXXMethodDecl *Method
3035              = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
3036          Method->setAccess(OldTemplateDecl->getAccess());
3037          NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
3038        }
3039
3040        // If this is an explicit specialization of a member that is a function
3041        // template, mark it as a member specialization.
3042        if (IsExplicitSpecialization &&
3043            NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
3044          NewTemplateDecl->setMemberSpecialization();
3045          assert(OldTemplateDecl->isMemberSpecialization());
3046        }
3047      } else {
3048        if (isa<CXXMethodDecl>(NewFD)) // Set access for out-of-line definitions
3049          NewFD->setAccess(OldDecl->getAccess());
3050        NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
3051      }
3052    }
3053  }
3054
3055  // Semantic checking for this function declaration (in isolation).
3056  if (getLangOptions().CPlusPlus) {
3057    // C++-specific checks.
3058    if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
3059      CheckConstructor(Constructor);
3060    } else if (isa<CXXDestructorDecl>(NewFD)) {
3061      CXXRecordDecl *Record = cast<CXXRecordDecl>(NewFD->getParent());
3062      QualType ClassType = Context.getTypeDeclType(Record);
3063      if (!ClassType->isDependentType()) {
3064        DeclarationName Name
3065          = Context.DeclarationNames.getCXXDestructorName(
3066                                        Context.getCanonicalType(ClassType));
3067        if (NewFD->getDeclName() != Name) {
3068          Diag(NewFD->getLocation(), diag::err_destructor_name);
3069          return NewFD->setInvalidDecl();
3070        }
3071      }
3072      Record->setUserDeclaredDestructor(true);
3073      // C++ [class]p4: A POD-struct is an aggregate class that has [...] no
3074      // user-defined destructor.
3075      Record->setPOD(false);
3076
3077      // C++ [class.dtor]p3: A destructor is trivial if it is an implicitly-
3078      // declared destructor.
3079      // FIXME: C++0x: don't do this for "= default" destructors
3080      Record->setHasTrivialDestructor(false);
3081    } else if (CXXConversionDecl *Conversion
3082               = dyn_cast<CXXConversionDecl>(NewFD))
3083      ActOnConversionDeclarator(Conversion);
3084
3085    // Extra checking for C++ overloaded operators (C++ [over.oper]).
3086    if (NewFD->isOverloadedOperator() &&
3087        CheckOverloadedOperatorDeclaration(NewFD))
3088      return NewFD->setInvalidDecl();
3089
3090    // In C++, check default arguments now that we have merged decls. Unless
3091    // the lexical context is the class, because in this case this is done
3092    // during delayed parsing anyway.
3093    if (!CurContext->isRecord())
3094      CheckCXXDefaultArguments(NewFD);
3095  }
3096}
3097
3098void Sema::CheckMain(FunctionDecl* FD) {
3099  // C++ [basic.start.main]p3:  A program that declares main to be inline
3100  //   or static is ill-formed.
3101  // C99 6.7.4p4:  In a hosted environment, the inline function specifier
3102  //   shall not appear in a declaration of main.
3103  // static main is not an error under C99, but we should warn about it.
3104  bool isInline = FD->isInline();
3105  bool isStatic = FD->getStorageClass() == FunctionDecl::Static;
3106  if (isInline || isStatic) {
3107    unsigned diagID = diag::warn_unusual_main_decl;
3108    if (isInline || getLangOptions().CPlusPlus)
3109      diagID = diag::err_unusual_main_decl;
3110
3111    int which = isStatic + (isInline << 1) - 1;
3112    Diag(FD->getLocation(), diagID) << which;
3113  }
3114
3115  QualType T = FD->getType();
3116  assert(T->isFunctionType() && "function decl is not of function type");
3117  const FunctionType* FT = T->getAs<FunctionType>();
3118
3119  if (!Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
3120    // TODO: add a replacement fixit to turn the return type into 'int'.
3121    Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
3122    FD->setInvalidDecl(true);
3123  }
3124
3125  // Treat protoless main() as nullary.
3126  if (isa<FunctionNoProtoType>(FT)) return;
3127
3128  const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
3129  unsigned nparams = FTP->getNumArgs();
3130  assert(FD->getNumParams() == nparams);
3131
3132  if (nparams > 3) {
3133    Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
3134    FD->setInvalidDecl(true);
3135    nparams = 3;
3136  }
3137
3138  // FIXME: a lot of the following diagnostics would be improved
3139  // if we had some location information about types.
3140
3141  QualType CharPP =
3142    Context.getPointerType(Context.getPointerType(Context.CharTy));
3143  QualType Expected[] = { Context.IntTy, CharPP, CharPP };
3144
3145  for (unsigned i = 0; i < nparams; ++i) {
3146    QualType AT = FTP->getArgType(i);
3147
3148    bool mismatch = true;
3149
3150    if (Context.hasSameUnqualifiedType(AT, Expected[i]))
3151      mismatch = false;
3152    else if (Expected[i] == CharPP) {
3153      // As an extension, the following forms are okay:
3154      //   char const **
3155      //   char const * const *
3156      //   char * const *
3157
3158      QualifierCollector qs;
3159      const PointerType* PT;
3160      if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
3161          (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
3162          (QualType(qs.strip(PT->getPointeeType()), 0) == Context.CharTy)) {
3163        qs.removeConst();
3164        mismatch = !qs.empty();
3165      }
3166    }
3167
3168    if (mismatch) {
3169      Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
3170      // TODO: suggest replacing given type with expected type
3171      FD->setInvalidDecl(true);
3172    }
3173  }
3174
3175  if (nparams == 1 && !FD->isInvalidDecl()) {
3176    Diag(FD->getLocation(), diag::warn_main_one_arg);
3177  }
3178}
3179
3180bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
3181  // FIXME: Need strict checking.  In C89, we need to check for
3182  // any assignment, increment, decrement, function-calls, or
3183  // commas outside of a sizeof.  In C99, it's the same list,
3184  // except that the aforementioned are allowed in unevaluated
3185  // expressions.  Everything else falls under the
3186  // "may accept other forms of constant expressions" exception.
3187  // (We never end up here for C++, so the constant expression
3188  // rules there don't matter.)
3189  if (Init->isConstantInitializer(Context))
3190    return false;
3191  Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
3192    << Init->getSourceRange();
3193  return true;
3194}
3195
3196void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init) {
3197  AddInitializerToDecl(dcl, move(init), /*DirectInit=*/false);
3198}
3199
3200/// AddInitializerToDecl - Adds the initializer Init to the
3201/// declaration dcl. If DirectInit is true, this is C++ direct
3202/// initialization rather than copy initialization.
3203void Sema::AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit) {
3204  Decl *RealDecl = dcl.getAs<Decl>();
3205  // If there is no declaration, there was an error parsing it.  Just ignore
3206  // the initializer.
3207  if (RealDecl == 0)
3208    return;
3209
3210  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
3211    // With declarators parsed the way they are, the parser cannot
3212    // distinguish between a normal initializer and a pure-specifier.
3213    // Thus this grotesque test.
3214    IntegerLiteral *IL;
3215    Expr *Init = static_cast<Expr *>(init.get());
3216    if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
3217        Context.getCanonicalType(IL->getType()) == Context.IntTy) {
3218      if (Method->isVirtualAsWritten()) {
3219        Method->setPure();
3220
3221        // A class is abstract if at least one function is pure virtual.
3222        cast<CXXRecordDecl>(CurContext)->setAbstract(true);
3223      } else if (!Method->isInvalidDecl()) {
3224        Diag(Method->getLocation(), diag::err_non_virtual_pure)
3225          << Method->getDeclName() << Init->getSourceRange();
3226        Method->setInvalidDecl();
3227      }
3228    } else {
3229      Diag(Method->getLocation(), diag::err_member_function_initialization)
3230        << Method->getDeclName() << Init->getSourceRange();
3231      Method->setInvalidDecl();
3232    }
3233    return;
3234  }
3235
3236  VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
3237  if (!VDecl) {
3238    if (getLangOptions().CPlusPlus &&
3239        RealDecl->getLexicalDeclContext()->isRecord() &&
3240        isa<NamedDecl>(RealDecl))
3241      Diag(RealDecl->getLocation(), diag::err_member_initialization)
3242        << cast<NamedDecl>(RealDecl)->getDeclName();
3243    else
3244      Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
3245    RealDecl->setInvalidDecl();
3246    return;
3247  }
3248
3249  if (!VDecl->getType()->isArrayType() &&
3250      RequireCompleteType(VDecl->getLocation(), VDecl->getType(),
3251                          diag::err_typecheck_decl_incomplete_type)) {
3252    RealDecl->setInvalidDecl();
3253    return;
3254  }
3255
3256  const VarDecl *Def = 0;
3257  if (VDecl->getDefinition(Def)) {
3258    Diag(VDecl->getLocation(), diag::err_redefinition)
3259      << VDecl->getDeclName();
3260    Diag(Def->getLocation(), diag::note_previous_definition);
3261    VDecl->setInvalidDecl();
3262    return;
3263  }
3264
3265  // Take ownership of the expression, now that we're sure we have somewhere
3266  // to put it.
3267  Expr *Init = init.takeAs<Expr>();
3268  assert(Init && "missing initializer");
3269
3270  // Get the decls type and save a reference for later, since
3271  // CheckInitializerTypes may change it.
3272  QualType DclT = VDecl->getType(), SavT = DclT;
3273  if (VDecl->isBlockVarDecl()) {
3274    if (VDecl->hasExternalStorage()) { // C99 6.7.8p5
3275      Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
3276      VDecl->setInvalidDecl();
3277    } else if (!VDecl->isInvalidDecl()) {
3278      if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
3279                                VDecl->getDeclName(), DirectInit))
3280        VDecl->setInvalidDecl();
3281
3282      // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3283      // Don't check invalid declarations to avoid emitting useless diagnostics.
3284      if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3285        if (VDecl->getStorageClass() == VarDecl::Static) // C99 6.7.8p4.
3286          CheckForConstantInitializer(Init, DclT);
3287      }
3288    }
3289  } else if (VDecl->isStaticDataMember() &&
3290             VDecl->getLexicalDeclContext()->isRecord()) {
3291    // This is an in-class initialization for a static data member, e.g.,
3292    //
3293    // struct S {
3294    //   static const int value = 17;
3295    // };
3296
3297    // Attach the initializer
3298    VDecl->setInit(Context, Init);
3299
3300    // C++ [class.mem]p4:
3301    //   A member-declarator can contain a constant-initializer only
3302    //   if it declares a static member (9.4) of const integral or
3303    //   const enumeration type, see 9.4.2.
3304    QualType T = VDecl->getType();
3305    if (!T->isDependentType() &&
3306        (!Context.getCanonicalType(T).isConstQualified() ||
3307         !T->isIntegralType())) {
3308      Diag(VDecl->getLocation(), diag::err_member_initialization)
3309        << VDecl->getDeclName() << Init->getSourceRange();
3310      VDecl->setInvalidDecl();
3311    } else {
3312      // C++ [class.static.data]p4:
3313      //   If a static data member is of const integral or const
3314      //   enumeration type, its declaration in the class definition
3315      //   can specify a constant-initializer which shall be an
3316      //   integral constant expression (5.19).
3317      if (!Init->isTypeDependent() &&
3318          !Init->getType()->isIntegralType()) {
3319        // We have a non-dependent, non-integral or enumeration type.
3320        Diag(Init->getSourceRange().getBegin(),
3321             diag::err_in_class_initializer_non_integral_type)
3322          << Init->getType() << Init->getSourceRange();
3323        VDecl->setInvalidDecl();
3324      } else if (!Init->isTypeDependent() && !Init->isValueDependent()) {
3325        // Check whether the expression is a constant expression.
3326        llvm::APSInt Value;
3327        SourceLocation Loc;
3328        if (!Init->isIntegerConstantExpr(Value, Context, &Loc)) {
3329          Diag(Loc, diag::err_in_class_initializer_non_constant)
3330            << Init->getSourceRange();
3331          VDecl->setInvalidDecl();
3332        } else if (!VDecl->getType()->isDependentType())
3333          ImpCastExprToType(Init, VDecl->getType(), CastExpr::CK_IntegralCast);
3334      }
3335    }
3336  } else if (VDecl->isFileVarDecl()) {
3337    if (VDecl->getStorageClass() == VarDecl::Extern)
3338      Diag(VDecl->getLocation(), diag::warn_extern_init);
3339    if (!VDecl->isInvalidDecl())
3340      if (CheckInitializerTypes(Init, DclT, VDecl->getLocation(),
3341                                VDecl->getDeclName(), DirectInit))
3342        VDecl->setInvalidDecl();
3343
3344    // C++ 3.6.2p2, allow dynamic initialization of static initializers.
3345    // Don't check invalid declarations to avoid emitting useless diagnostics.
3346    if (!getLangOptions().CPlusPlus && !VDecl->isInvalidDecl()) {
3347      // C99 6.7.8p4. All file scoped initializers need to be constant.
3348      CheckForConstantInitializer(Init, DclT);
3349    }
3350  }
3351  // If the type changed, it means we had an incomplete type that was
3352  // completed by the initializer. For example:
3353  //   int ary[] = { 1, 3, 5 };
3354  // "ary" transitions from a VariableArrayType to a ConstantArrayType.
3355  if (!VDecl->isInvalidDecl() && (DclT != SavT)) {
3356    VDecl->setType(DclT);
3357    Init->setType(DclT);
3358  }
3359
3360  Init = MaybeCreateCXXExprWithTemporaries(Init,
3361                                           /*ShouldDestroyTemporaries=*/true);
3362  // Attach the initializer to the decl.
3363  VDecl->setInit(Context, Init);
3364
3365  // If the previous declaration of VDecl was a tentative definition,
3366  // remove it from the set of tentative definitions.
3367  if (VDecl->getPreviousDeclaration() &&
3368      VDecl->getPreviousDeclaration()->isTentativeDefinition(Context)) {
3369    bool Deleted = TentativeDefinitions.erase(VDecl->getDeclName());
3370    assert(Deleted && "Unrecorded tentative definition?"); Deleted=Deleted;
3371  }
3372
3373  return;
3374}
3375
3376void Sema::ActOnUninitializedDecl(DeclPtrTy dcl,
3377                                  bool TypeContainsUndeducedAuto) {
3378  Decl *RealDecl = dcl.getAs<Decl>();
3379
3380  // If there is no declaration, there was an error parsing it. Just ignore it.
3381  if (RealDecl == 0)
3382    return;
3383
3384  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
3385    QualType Type = Var->getType();
3386
3387    // Record tentative definitions.
3388    if (Var->isTentativeDefinition(Context)) {
3389      std::pair<llvm::DenseMap<DeclarationName, VarDecl *>::iterator, bool>
3390        InsertPair =
3391           TentativeDefinitions.insert(std::make_pair(Var->getDeclName(), Var));
3392
3393      // Keep the latest definition in the map.  If we see 'int i; int i;' we
3394      // want the second one in the map.
3395      InsertPair.first->second = Var;
3396
3397      // However, for the list, we don't care about the order, just make sure
3398      // that there are no dupes for a given declaration name.
3399      if (InsertPair.second)
3400        TentativeDefinitionList.push_back(Var->getDeclName());
3401    }
3402
3403    // C++ [dcl.init.ref]p3:
3404    //   The initializer can be omitted for a reference only in a
3405    //   parameter declaration (8.3.5), in the declaration of a
3406    //   function return type, in the declaration of a class member
3407    //   within its class declaration (9.2), and where the extern
3408    //   specifier is explicitly used.
3409    if (Type->isReferenceType() && !Var->hasExternalStorage()) {
3410      Diag(Var->getLocation(), diag::err_reference_var_requires_init)
3411        << Var->getDeclName()
3412        << SourceRange(Var->getLocation(), Var->getLocation());
3413      Var->setInvalidDecl();
3414      return;
3415    }
3416
3417    // C++0x [dcl.spec.auto]p3
3418    if (TypeContainsUndeducedAuto) {
3419      Diag(Var->getLocation(), diag::err_auto_var_requires_init)
3420        << Var->getDeclName() << Type;
3421      Var->setInvalidDecl();
3422      return;
3423    }
3424
3425    // C++ [temp.expl.spec]p15:
3426    //   An explicit specialization of a static data member of a template is a
3427    //   definition if the declaration includes an initializer; otherwise, it
3428    //   is a declaration.
3429    if (Var->isStaticDataMember() &&
3430        Var->getInstantiatedFromStaticDataMember() &&
3431        Var->getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
3432      return;
3433
3434    // C++ [dcl.init]p9:
3435    //   If no initializer is specified for an object, and the object
3436    //   is of (possibly cv-qualified) non-POD class type (or array
3437    //   thereof), the object shall be default-initialized; if the
3438    //   object is of const-qualified type, the underlying class type
3439    //   shall have a user-declared default constructor.
3440    //
3441    // FIXME: Diagnose the "user-declared default constructor" bit.
3442    if (getLangOptions().CPlusPlus) {
3443      QualType InitType = Type;
3444      if (const ArrayType *Array = Context.getAsArrayType(Type))
3445        InitType = Array->getElementType();
3446      if ((!Var->hasExternalStorage() && !Var->isExternC()) &&
3447          InitType->isRecordType() && !InitType->isDependentType()) {
3448        if (!RequireCompleteType(Var->getLocation(), InitType,
3449                                 diag::err_invalid_incomplete_type_use)) {
3450          ASTOwningVector<&ActionBase::DeleteExpr> ConstructorArgs(*this);
3451
3452          CXXConstructorDecl *Constructor
3453            = PerformInitializationByConstructor(InitType,
3454                                                 MultiExprArg(*this, 0, 0),
3455                                                 Var->getLocation(),
3456                                               SourceRange(Var->getLocation(),
3457                                                           Var->getLocation()),
3458                                                 Var->getDeclName(),
3459                                                 IK_Default,
3460                                                 ConstructorArgs);
3461
3462          // FIXME: Location info for the variable initialization?
3463          if (!Constructor)
3464            Var->setInvalidDecl();
3465          else {
3466            // FIXME: Cope with initialization of arrays
3467            if (!Constructor->isTrivial() &&
3468                InitializeVarWithConstructor(Var, Constructor, InitType,
3469                                             move_arg(ConstructorArgs)))
3470              Var->setInvalidDecl();
3471
3472            FinalizeVarWithDestructor(Var, InitType);
3473          }
3474        } else {
3475          Var->setInvalidDecl();
3476        }
3477      }
3478    }
3479
3480#if 0
3481    // FIXME: Temporarily disabled because we are not properly parsing
3482    // linkage specifications on declarations, e.g.,
3483    //
3484    //   extern "C" const CGPoint CGPointerZero;
3485    //
3486    // C++ [dcl.init]p9:
3487    //
3488    //     If no initializer is specified for an object, and the
3489    //     object is of (possibly cv-qualified) non-POD class type (or
3490    //     array thereof), the object shall be default-initialized; if
3491    //     the object is of const-qualified type, the underlying class
3492    //     type shall have a user-declared default
3493    //     constructor. Otherwise, if no initializer is specified for
3494    //     an object, the object and its subobjects, if any, have an
3495    //     indeterminate initial value; if the object or any of its
3496    //     subobjects are of const-qualified type, the program is
3497    //     ill-formed.
3498    //
3499    // This isn't technically an error in C, so we don't diagnose it.
3500    //
3501    // FIXME: Actually perform the POD/user-defined default
3502    // constructor check.
3503    if (getLangOptions().CPlusPlus &&
3504        Context.getCanonicalType(Type).isConstQualified() &&
3505        !Var->hasExternalStorage())
3506      Diag(Var->getLocation(),  diag::err_const_var_requires_init)
3507        << Var->getName()
3508        << SourceRange(Var->getLocation(), Var->getLocation());
3509#endif
3510  }
3511}
3512
3513Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
3514                                                   DeclPtrTy *Group,
3515                                                   unsigned NumDecls) {
3516  llvm::SmallVector<Decl*, 8> Decls;
3517
3518  if (DS.isTypeSpecOwned())
3519    Decls.push_back((Decl*)DS.getTypeRep());
3520
3521  for (unsigned i = 0; i != NumDecls; ++i)
3522    if (Decl *D = Group[i].getAs<Decl>())
3523      Decls.push_back(D);
3524
3525  // Perform semantic analysis that depends on having fully processed both
3526  // the declarator and initializer.
3527  for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
3528    VarDecl *IDecl = dyn_cast<VarDecl>(Decls[i]);
3529    if (!IDecl)
3530      continue;
3531    QualType T = IDecl->getType();
3532
3533    // Block scope. C99 6.7p7: If an identifier for an object is declared with
3534    // no linkage (C99 6.2.2p6), the type for the object shall be complete...
3535    if (IDecl->isBlockVarDecl() && !IDecl->hasExternalStorage()) {
3536      if (T->isDependentType()) {
3537        // If T is dependent, we should not require a complete type.
3538        // (RequireCompleteType shouldn't be called with dependent types.)
3539        // But we still can at least check if we've got an array of unspecified
3540        // size without an initializer.
3541        if (!IDecl->isInvalidDecl() && T->isIncompleteArrayType() &&
3542            !IDecl->getInit()) {
3543          Diag(IDecl->getLocation(), diag::err_typecheck_decl_incomplete_type)
3544            << T;
3545          IDecl->setInvalidDecl();
3546        }
3547      } else if (!IDecl->isInvalidDecl()) {
3548        // If T is an incomplete array type with an initializer list that is
3549        // dependent on something, its size has not been fixed. We could attempt
3550        // to fix the size for such arrays, but we would still have to check
3551        // here for initializers containing a C++0x vararg expansion, e.g.
3552        // template <typename... Args> void f(Args... args) {
3553        //   int vals[] = { args };
3554        // }
3555        const IncompleteArrayType *IAT = T->getAs<IncompleteArrayType>();
3556        Expr *Init = IDecl->getInit();
3557        if (IAT && Init &&
3558            (Init->isTypeDependent() || Init->isValueDependent())) {
3559          // Check that the member type of the array is complete, at least.
3560          if (RequireCompleteType(IDecl->getLocation(), IAT->getElementType(),
3561                                  diag::err_typecheck_decl_incomplete_type))
3562            IDecl->setInvalidDecl();
3563        } else if (RequireCompleteType(IDecl->getLocation(), T,
3564                                      diag::err_typecheck_decl_incomplete_type))
3565          IDecl->setInvalidDecl();
3566      }
3567    }
3568    // File scope. C99 6.9.2p2: A declaration of an identifier for an
3569    // object that has file scope without an initializer, and without a
3570    // storage-class specifier or with the storage-class specifier "static",
3571    // constitutes a tentative definition. Note: A tentative definition with
3572    // external linkage is valid (C99 6.2.2p5).
3573    if (IDecl->isTentativeDefinition(Context) && !IDecl->isInvalidDecl()) {
3574      if (const IncompleteArrayType *ArrayT
3575          = Context.getAsIncompleteArrayType(T)) {
3576        if (RequireCompleteType(IDecl->getLocation(),
3577                                ArrayT->getElementType(),
3578                                diag::err_illegal_decl_array_incomplete_type))
3579          IDecl->setInvalidDecl();
3580      } else if (IDecl->getStorageClass() == VarDecl::Static) {
3581        // C99 6.9.2p3: If the declaration of an identifier for an object is
3582        // a tentative definition and has internal linkage (C99 6.2.2p3), the
3583        // declared type shall not be an incomplete type.
3584        // NOTE: code such as the following
3585        //     static struct s;
3586        //     struct s { int a; };
3587        // is accepted by gcc. Hence here we issue a warning instead of
3588        // an error and we do not invalidate the static declaration.
3589        // NOTE: to avoid multiple warnings, only check the first declaration.
3590        if (IDecl->getPreviousDeclaration() == 0)
3591          RequireCompleteType(IDecl->getLocation(), T,
3592                              diag::ext_typecheck_decl_incomplete_type);
3593      }
3594    }
3595  }
3596  return DeclGroupPtrTy::make(DeclGroupRef::Create(Context,
3597                                                   Decls.data(), Decls.size()));
3598}
3599
3600
3601/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
3602/// to introduce parameters into function prototype scope.
3603Sema::DeclPtrTy
3604Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
3605  const DeclSpec &DS = D.getDeclSpec();
3606
3607  // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
3608  VarDecl::StorageClass StorageClass = VarDecl::None;
3609  if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
3610    StorageClass = VarDecl::Register;
3611  } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
3612    Diag(DS.getStorageClassSpecLoc(),
3613         diag::err_invalid_storage_class_in_func_decl);
3614    D.getMutableDeclSpec().ClearStorageClassSpecs();
3615  }
3616
3617  if (D.getDeclSpec().isThreadSpecified())
3618    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
3619
3620  DiagnoseFunctionSpecifiers(D);
3621
3622  // Check that there are no default arguments inside the type of this
3623  // parameter (C++ only).
3624  if (getLangOptions().CPlusPlus)
3625    CheckExtraCXXDefaultArguments(D);
3626
3627  DeclaratorInfo *DInfo = 0;
3628  TagDecl *OwnedDecl = 0;
3629  QualType parmDeclType = GetTypeForDeclarator(D, S, &DInfo, /*Skip=*/0,
3630                                               &OwnedDecl);
3631
3632  if (getLangOptions().CPlusPlus && OwnedDecl && OwnedDecl->isDefinition()) {
3633    // C++ [dcl.fct]p6:
3634    //   Types shall not be defined in return or parameter types.
3635    Diag(OwnedDecl->getLocation(), diag::err_type_defined_in_param_type)
3636      << Context.getTypeDeclType(OwnedDecl);
3637  }
3638
3639  // TODO: CHECK FOR CONFLICTS, multiple decls with same name in one scope.
3640  // Can this happen for params?  We already checked that they don't conflict
3641  // among each other.  Here they can only shadow globals, which is ok.
3642  IdentifierInfo *II = D.getIdentifier();
3643  if (II) {
3644    if (NamedDecl *PrevDecl = LookupSingleName(S, II, LookupOrdinaryName)) {
3645      if (PrevDecl->isTemplateParameter()) {
3646        // Maybe we will complain about the shadowed template parameter.
3647        DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
3648        // Just pretend that we didn't see the previous declaration.
3649        PrevDecl = 0;
3650      } else if (S->isDeclScope(DeclPtrTy::make(PrevDecl))) {
3651        Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
3652
3653        // Recover by removing the name
3654        II = 0;
3655        D.SetIdentifier(0, D.getIdentifierLoc());
3656      }
3657    }
3658  }
3659
3660  // Parameters can not be abstract class types.
3661  // For record types, this is done by the AbstractClassUsageDiagnoser once
3662  // the class has been completely parsed.
3663  if (!CurContext->isRecord() &&
3664      RequireNonAbstractType(D.getIdentifierLoc(), parmDeclType,
3665                             diag::err_abstract_type_in_decl,
3666                             AbstractParamType))
3667    D.setInvalidType(true);
3668
3669  QualType T = adjustParameterType(parmDeclType);
3670
3671  ParmVarDecl *New;
3672  if (T == parmDeclType) // parameter type did not need adjustment
3673    New = ParmVarDecl::Create(Context, CurContext,
3674                              D.getIdentifierLoc(), II,
3675                              parmDeclType, DInfo, StorageClass,
3676                              0);
3677  else // keep track of both the adjusted and unadjusted types
3678    New = OriginalParmVarDecl::Create(Context, CurContext,
3679                                      D.getIdentifierLoc(), II, T, DInfo,
3680                                      parmDeclType, StorageClass, 0);
3681
3682  if (D.isInvalidType())
3683    New->setInvalidDecl();
3684
3685  // Parameter declarators cannot be interface types. All ObjC objects are
3686  // passed by reference.
3687  if (T->isObjCInterfaceType()) {
3688    Diag(D.getIdentifierLoc(),
3689         diag::err_object_cannot_be_passed_returned_by_value) << 1 << T;
3690    New->setInvalidDecl();
3691  }
3692
3693  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
3694  if (D.getCXXScopeSpec().isSet()) {
3695    Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
3696      << D.getCXXScopeSpec().getRange();
3697    New->setInvalidDecl();
3698  }
3699
3700  // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
3701  // duration shall not be qualified by an address-space qualifier."
3702  // Since all parameters have automatic store duration, they can not have
3703  // an address space.
3704  if (T.getAddressSpace() != 0) {
3705    Diag(D.getIdentifierLoc(),
3706         diag::err_arg_with_address_space);
3707    New->setInvalidDecl();
3708  }
3709
3710
3711  // Add the parameter declaration into this scope.
3712  S->AddDecl(DeclPtrTy::make(New));
3713  if (II)
3714    IdResolver.AddDecl(New);
3715
3716  ProcessDeclAttributes(S, New, D);
3717
3718  if (New->hasAttr<BlocksAttr>()) {
3719    Diag(New->getLocation(), diag::err_block_on_nonlocal);
3720  }
3721  return DeclPtrTy::make(New);
3722}
3723
3724void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
3725                                           SourceLocation LocAfterDecls) {
3726  assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3727         "Not a function declarator!");
3728  DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3729
3730  // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
3731  // for a K&R function.
3732  if (!FTI.hasPrototype) {
3733    for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
3734      --i;
3735      if (FTI.ArgInfo[i].Param == 0) {
3736        llvm::SmallString<256> Code;
3737        llvm::raw_svector_ostream(Code) << "  int "
3738                                        << FTI.ArgInfo[i].Ident->getName()
3739                                        << ";\n";
3740        Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
3741          << FTI.ArgInfo[i].Ident
3742          << CodeModificationHint::CreateInsertion(LocAfterDecls, Code.str());
3743
3744        // Implicitly declare the argument as type 'int' for lack of a better
3745        // type.
3746        DeclSpec DS;
3747        const char* PrevSpec; // unused
3748        unsigned DiagID; // unused
3749        DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
3750                           PrevSpec, DiagID);
3751        Declarator ParamD(DS, Declarator::KNRTypeListContext);
3752        ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
3753        FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
3754      }
3755    }
3756  }
3757}
3758
3759Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope,
3760                                              Declarator &D) {
3761  assert(getCurFunctionDecl() == 0 && "Function parsing confused");
3762  assert(D.getTypeObject(0).Kind == DeclaratorChunk::Function &&
3763         "Not a function declarator!");
3764  DeclaratorChunk::FunctionTypeInfo &FTI = D.getTypeObject(0).Fun;
3765
3766  if (FTI.hasPrototype) {
3767    // FIXME: Diagnose arguments without names in C.
3768  }
3769
3770  Scope *ParentScope = FnBodyScope->getParent();
3771
3772  DeclPtrTy DP = HandleDeclarator(ParentScope, D,
3773                                  MultiTemplateParamsArg(*this),
3774                                  /*IsFunctionDefinition=*/true);
3775  return ActOnStartOfFunctionDef(FnBodyScope, DP);
3776}
3777
3778Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) {
3779  if (!D)
3780    return D;
3781  FunctionDecl *FD = 0;
3782
3783  if (FunctionTemplateDecl *FunTmpl
3784        = dyn_cast<FunctionTemplateDecl>(D.getAs<Decl>()))
3785    FD = FunTmpl->getTemplatedDecl();
3786  else
3787    FD = cast<FunctionDecl>(D.getAs<Decl>());
3788
3789  CurFunctionNeedsScopeChecking = false;
3790
3791  // See if this is a redefinition.
3792  const FunctionDecl *Definition;
3793  if (FD->getBody(Definition)) {
3794    Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
3795    Diag(Definition->getLocation(), diag::note_previous_definition);
3796  }
3797
3798  // Builtin functions cannot be defined.
3799  if (unsigned BuiltinID = FD->getBuiltinID()) {
3800    if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3801      Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
3802      FD->setInvalidDecl();
3803    }
3804  }
3805
3806  // The return type of a function definition must be complete
3807  // (C99 6.9.1p3, C++ [dcl.fct]p6).
3808  QualType ResultType = FD->getResultType();
3809  if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
3810      !FD->isInvalidDecl() &&
3811      RequireCompleteType(FD->getLocation(), ResultType,
3812                          diag::err_func_def_incomplete_result))
3813    FD->setInvalidDecl();
3814
3815  // GNU warning -Wmissing-prototypes:
3816  //   Warn if a global function is defined without a previous
3817  //   prototype declaration. This warning is issued even if the
3818  //   definition itself provides a prototype. The aim is to detect
3819  //   global functions that fail to be declared in header files.
3820  if (!FD->isInvalidDecl() && FD->isGlobal() && !isa<CXXMethodDecl>(FD) &&
3821      !FD->isMain()) {
3822    bool MissingPrototype = true;
3823    for (const FunctionDecl *Prev = FD->getPreviousDeclaration();
3824         Prev; Prev = Prev->getPreviousDeclaration()) {
3825      // Ignore any declarations that occur in function or method
3826      // scope, because they aren't visible from the header.
3827      if (Prev->getDeclContext()->isFunctionOrMethod())
3828        continue;
3829
3830      MissingPrototype = !Prev->getType()->isFunctionProtoType();
3831      break;
3832    }
3833
3834    if (MissingPrototype)
3835      Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
3836  }
3837
3838  if (FnBodyScope)
3839    PushDeclContext(FnBodyScope, FD);
3840
3841  // Check the validity of our function parameters
3842  CheckParmsForFunctionDef(FD);
3843
3844  // Introduce our parameters into the function scope
3845  for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
3846    ParmVarDecl *Param = FD->getParamDecl(p);
3847    Param->setOwningFunction(FD);
3848
3849    // If this has an identifier, add it to the scope stack.
3850    if (Param->getIdentifier() && FnBodyScope)
3851      PushOnScopeChains(Param, FnBodyScope);
3852  }
3853
3854  // Checking attributes of current function definition
3855  // dllimport attribute.
3856  if (FD->getAttr<DLLImportAttr>() &&
3857      (!FD->getAttr<DLLExportAttr>())) {
3858    // dllimport attribute cannot be applied to definition.
3859    if (!(FD->getAttr<DLLImportAttr>())->isInherited()) {
3860      Diag(FD->getLocation(),
3861           diag::err_attribute_can_be_applied_only_to_symbol_declaration)
3862        << "dllimport";
3863      FD->setInvalidDecl();
3864      return DeclPtrTy::make(FD);
3865    } else {
3866      // If a symbol previously declared dllimport is later defined, the
3867      // attribute is ignored in subsequent references, and a warning is
3868      // emitted.
3869      Diag(FD->getLocation(),
3870           diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
3871        << FD->getNameAsCString() << "dllimport";
3872    }
3873  }
3874  return DeclPtrTy::make(FD);
3875}
3876
3877Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg) {
3878  return ActOnFinishFunctionBody(D, move(BodyArg), false);
3879}
3880
3881Sema::DeclPtrTy Sema::ActOnFinishFunctionBody(DeclPtrTy D, StmtArg BodyArg,
3882                                              bool IsInstantiation) {
3883  Decl *dcl = D.getAs<Decl>();
3884  Stmt *Body = BodyArg.takeAs<Stmt>();
3885
3886  FunctionDecl *FD = 0;
3887  FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
3888  if (FunTmpl)
3889    FD = FunTmpl->getTemplatedDecl();
3890  else
3891    FD = dyn_cast_or_null<FunctionDecl>(dcl);
3892
3893  if (FD) {
3894    FD->setBody(Body);
3895    if (FD->isMain())
3896      // C and C++ allow for main to automagically return 0.
3897      // Implements C++ [basic.start.main]p5 and C99 5.1.2.2.3.
3898      FD->setHasImplicitReturnZero(true);
3899    else
3900      CheckFallThroughForFunctionDef(FD, Body);
3901
3902    if (!FD->isInvalidDecl())
3903      DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
3904
3905    // C++ [basic.def.odr]p2:
3906    //   [...] A virtual member function is used if it is not pure. [...]
3907    if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FD))
3908      if (Method->isVirtual() && !Method->isPure())
3909        MarkDeclarationReferenced(Method->getLocation(), Method);
3910
3911    assert(FD == getCurFunctionDecl() && "Function parsing confused");
3912  } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
3913    assert(MD == getCurMethodDecl() && "Method parsing confused");
3914    MD->setBody(Body);
3915    CheckFallThroughForFunctionDef(MD, Body);
3916    MD->setEndLoc(Body->getLocEnd());
3917
3918    if (!MD->isInvalidDecl())
3919      DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
3920  } else {
3921    Body->Destroy(Context);
3922    return DeclPtrTy();
3923  }
3924  if (!IsInstantiation)
3925    PopDeclContext();
3926
3927  // Verify and clean out per-function state.
3928
3929  assert(&getLabelMap() == &FunctionLabelMap && "Didn't pop block right?");
3930
3931  // Check goto/label use.
3932  for (llvm::DenseMap<IdentifierInfo*, LabelStmt*>::iterator
3933       I = FunctionLabelMap.begin(), E = FunctionLabelMap.end(); I != E; ++I) {
3934    LabelStmt *L = I->second;
3935
3936    // Verify that we have no forward references left.  If so, there was a goto
3937    // or address of a label taken, but no definition of it.  Label fwd
3938    // definitions are indicated with a null substmt.
3939    if (L->getSubStmt() != 0)
3940      continue;
3941
3942    // Emit error.
3943    Diag(L->getIdentLoc(), diag::err_undeclared_label_use) << L->getName();
3944
3945    // At this point, we have gotos that use the bogus label.  Stitch it into
3946    // the function body so that they aren't leaked and that the AST is well
3947    // formed.
3948    if (Body == 0) {
3949      // The whole function wasn't parsed correctly, just delete this.
3950      L->Destroy(Context);
3951      continue;
3952    }
3953
3954    // Otherwise, the body is valid: we want to stitch the label decl into the
3955    // function somewhere so that it is properly owned and so that the goto
3956    // has a valid target.  Do this by creating a new compound stmt with the
3957    // label in it.
3958
3959    // Give the label a sub-statement.
3960    L->setSubStmt(new (Context) NullStmt(L->getIdentLoc()));
3961
3962    CompoundStmt *Compound = isa<CXXTryStmt>(Body) ?
3963                               cast<CXXTryStmt>(Body)->getTryBlock() :
3964                               cast<CompoundStmt>(Body);
3965    std::vector<Stmt*> Elements(Compound->body_begin(), Compound->body_end());
3966    Elements.push_back(L);
3967    Compound->setStmts(Context, &Elements[0], Elements.size());
3968  }
3969  FunctionLabelMap.clear();
3970
3971  if (!Body) return D;
3972
3973  // Verify that that gotos and switch cases don't jump into scopes illegally.
3974  if (CurFunctionNeedsScopeChecking)
3975    DiagnoseInvalidJumps(Body);
3976
3977  // C++ constructors that have function-try-blocks can't have return
3978  // statements in the handlers of that block. (C++ [except.handle]p14)
3979  // Verify this.
3980  if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
3981    DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
3982
3983  if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl))
3984    computeBaseOrMembersToDestroy(Destructor);
3985  return D;
3986}
3987
3988/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
3989/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
3990NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
3991                                          IdentifierInfo &II, Scope *S) {
3992  // Before we produce a declaration for an implicitly defined
3993  // function, see whether there was a locally-scoped declaration of
3994  // this name as a function or variable. If so, use that
3995  // (non-visible) declaration, and complain about it.
3996  llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
3997    = LocallyScopedExternalDecls.find(&II);
3998  if (Pos != LocallyScopedExternalDecls.end()) {
3999    Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
4000    Diag(Pos->second->getLocation(), diag::note_previous_declaration);
4001    return Pos->second;
4002  }
4003
4004  // Extension in C99.  Legal in C90, but warn about it.
4005  if (II.getName().startswith("__builtin_"))
4006    Diag(Loc, diag::warn_builtin_unknown) << &II;
4007  else if (getLangOptions().C99)
4008    Diag(Loc, diag::ext_implicit_function_decl) << &II;
4009  else
4010    Diag(Loc, diag::warn_implicit_function_decl) << &II;
4011
4012  // Set a Declarator for the implicit definition: int foo();
4013  const char *Dummy;
4014  DeclSpec DS;
4015  unsigned DiagID;
4016  bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
4017  Error = Error; // Silence warning.
4018  assert(!Error && "Error setting up implicit decl!");
4019  Declarator D(DS, Declarator::BlockContext);
4020  D.AddTypeInfo(DeclaratorChunk::getFunction(false, false, SourceLocation(), 0,
4021                                             0, 0, false, SourceLocation(),
4022                                             false, 0,0,0, Loc, Loc, D),
4023                SourceLocation());
4024  D.SetIdentifier(&II, Loc);
4025
4026  // Insert this function into translation-unit scope.
4027
4028  DeclContext *PrevDC = CurContext;
4029  CurContext = Context.getTranslationUnitDecl();
4030
4031  FunctionDecl *FD =
4032 dyn_cast<FunctionDecl>(ActOnDeclarator(TUScope, D).getAs<Decl>());
4033  FD->setImplicit();
4034
4035  CurContext = PrevDC;
4036
4037  AddKnownFunctionAttributes(FD);
4038
4039  return FD;
4040}
4041
4042/// \brief Adds any function attributes that we know a priori based on
4043/// the declaration of this function.
4044///
4045/// These attributes can apply both to implicitly-declared builtins
4046/// (like __builtin___printf_chk) or to library-declared functions
4047/// like NSLog or printf.
4048void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
4049  if (FD->isInvalidDecl())
4050    return;
4051
4052  // If this is a built-in function, map its builtin attributes to
4053  // actual attributes.
4054  if (unsigned BuiltinID = FD->getBuiltinID()) {
4055    // Handle printf-formatting attributes.
4056    unsigned FormatIdx;
4057    bool HasVAListArg;
4058    if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
4059      if (!FD->getAttr<FormatAttr>())
4060        FD->addAttr(::new (Context) FormatAttr("printf", FormatIdx + 1,
4061                                             HasVAListArg ? 0 : FormatIdx + 2));
4062    }
4063
4064    // Mark const if we don't care about errno and that is the only
4065    // thing preventing the function from being const. This allows
4066    // IRgen to use LLVM intrinsics for such functions.
4067    if (!getLangOptions().MathErrno &&
4068        Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
4069      if (!FD->getAttr<ConstAttr>())
4070        FD->addAttr(::new (Context) ConstAttr());
4071    }
4072
4073    if (Context.BuiltinInfo.isNoReturn(BuiltinID))
4074      FD->addAttr(::new (Context) NoReturnAttr());
4075  }
4076
4077  IdentifierInfo *Name = FD->getIdentifier();
4078  if (!Name)
4079    return;
4080  if ((!getLangOptions().CPlusPlus &&
4081       FD->getDeclContext()->isTranslationUnit()) ||
4082      (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
4083       cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
4084       LinkageSpecDecl::lang_c)) {
4085    // Okay: this could be a libc/libm/Objective-C function we know
4086    // about.
4087  } else
4088    return;
4089
4090  if (Name->isStr("NSLog") || Name->isStr("NSLogv")) {
4091    // FIXME: NSLog and NSLogv should be target specific
4092    if (const FormatAttr *Format = FD->getAttr<FormatAttr>()) {
4093      // FIXME: We known better than our headers.
4094      const_cast<FormatAttr *>(Format)->setType("printf");
4095    } else
4096      FD->addAttr(::new (Context) FormatAttr("printf", 1,
4097                                             Name->isStr("NSLogv") ? 0 : 2));
4098  } else if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
4099    // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
4100    // target-specific builtins, perhaps?
4101    if (!FD->getAttr<FormatAttr>())
4102      FD->addAttr(::new (Context) FormatAttr("printf", 2,
4103                                             Name->isStr("vasprintf") ? 0 : 3));
4104  }
4105}
4106
4107TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T) {
4108  assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
4109  assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
4110
4111  // Scope manipulation handled by caller.
4112  TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
4113                                           D.getIdentifierLoc(),
4114                                           D.getIdentifier(),
4115                                           T);
4116
4117  if (const TagType *TT = T->getAs<TagType>()) {
4118    TagDecl *TD = TT->getDecl();
4119
4120    // If the TagDecl that the TypedefDecl points to is an anonymous decl
4121    // keep track of the TypedefDecl.
4122    if (!TD->getIdentifier() && !TD->getTypedefForAnonDecl())
4123      TD->setTypedefForAnonDecl(NewTD);
4124  }
4125
4126  if (D.isInvalidType())
4127    NewTD->setInvalidDecl();
4128  return NewTD;
4129}
4130
4131
4132/// \brief Determine whether a tag with a given kind is acceptable
4133/// as a redeclaration of the given tag declaration.
4134///
4135/// \returns true if the new tag kind is acceptable, false otherwise.
4136bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
4137                                        TagDecl::TagKind NewTag,
4138                                        SourceLocation NewTagLoc,
4139                                        const IdentifierInfo &Name) {
4140  // C++ [dcl.type.elab]p3:
4141  //   The class-key or enum keyword present in the
4142  //   elaborated-type-specifier shall agree in kind with the
4143  //   declaration to which the name in theelaborated-type-specifier
4144  //   refers. This rule also applies to the form of
4145  //   elaborated-type-specifier that declares a class-name or
4146  //   friend class since it can be construed as referring to the
4147  //   definition of the class. Thus, in any
4148  //   elaborated-type-specifier, the enum keyword shall be used to
4149  //   refer to an enumeration (7.2), the union class-keyshall be
4150  //   used to refer to a union (clause 9), and either the class or
4151  //   struct class-key shall be used to refer to a class (clause 9)
4152  //   declared using the class or struct class-key.
4153  TagDecl::TagKind OldTag = Previous->getTagKind();
4154  if (OldTag == NewTag)
4155    return true;
4156
4157  if ((OldTag == TagDecl::TK_struct || OldTag == TagDecl::TK_class) &&
4158      (NewTag == TagDecl::TK_struct || NewTag == TagDecl::TK_class)) {
4159    // Warn about the struct/class tag mismatch.
4160    bool isTemplate = false;
4161    if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
4162      isTemplate = Record->getDescribedClassTemplate();
4163
4164    Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
4165      << (NewTag == TagDecl::TK_class)
4166      << isTemplate << &Name
4167      << CodeModificationHint::CreateReplacement(SourceRange(NewTagLoc),
4168                              OldTag == TagDecl::TK_class? "class" : "struct");
4169    Diag(Previous->getLocation(), diag::note_previous_use);
4170    return true;
4171  }
4172  return false;
4173}
4174
4175/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'.  In the
4176/// former case, Name will be non-null.  In the later case, Name will be null.
4177/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
4178/// reference/declaration/definition of a tag.
4179Sema::DeclPtrTy Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
4180                               SourceLocation KWLoc, const CXXScopeSpec &SS,
4181                               IdentifierInfo *Name, SourceLocation NameLoc,
4182                               AttributeList *Attr, AccessSpecifier AS,
4183                               MultiTemplateParamsArg TemplateParameterLists,
4184                               bool &OwnedDecl, bool &IsDependent) {
4185  // If this is not a definition, it must have a name.
4186  assert((Name != 0 || TUK == TUK_Definition) &&
4187         "Nameless record must be a definition!");
4188
4189  OwnedDecl = false;
4190  TagDecl::TagKind Kind = TagDecl::getTagKindForTypeSpec(TagSpec);
4191
4192  // FIXME: Check explicit specializations more carefully.
4193  bool isExplicitSpecialization = false;
4194  if (TUK != TUK_Reference) {
4195    if (TemplateParameterList *TemplateParams
4196          = MatchTemplateParametersToScopeSpecifier(KWLoc, SS,
4197                        (TemplateParameterList**)TemplateParameterLists.get(),
4198                                              TemplateParameterLists.size(),
4199                                                    isExplicitSpecialization)) {
4200      if (TemplateParams->size() > 0) {
4201        // This is a declaration or definition of a class template (which may
4202        // be a member of another template).
4203        OwnedDecl = false;
4204        DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
4205                                               SS, Name, NameLoc, Attr,
4206                                               TemplateParams,
4207                                               AS);
4208        TemplateParameterLists.release();
4209        return Result.get();
4210      } else {
4211        // The "template<>" header is extraneous.
4212        Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
4213          << ElaboratedType::getNameForTagKind(Kind) << Name;
4214        isExplicitSpecialization = true;
4215      }
4216    }
4217
4218    TemplateParameterLists.release();
4219  }
4220
4221  DeclContext *SearchDC = CurContext;
4222  DeclContext *DC = CurContext;
4223  NamedDecl *PrevDecl = 0;
4224  bool isStdBadAlloc = false;
4225  bool Invalid = false;
4226
4227  bool RedeclarationOnly = (TUK != TUK_Reference);
4228
4229  if (Name && SS.isNotEmpty()) {
4230    // We have a nested-name tag ('struct foo::bar').
4231
4232    // Check for invalid 'foo::'.
4233    if (SS.isInvalid()) {
4234      Name = 0;
4235      goto CreateNewDecl;
4236    }
4237
4238    // If this is a friend or a reference to a class in a dependent
4239    // context, don't try to make a decl for it.
4240    if (TUK == TUK_Friend || TUK == TUK_Reference) {
4241      DC = computeDeclContext(SS, false);
4242      if (!DC) {
4243        IsDependent = true;
4244        return DeclPtrTy();
4245      }
4246    }
4247
4248    if (RequireCompleteDeclContext(SS))
4249      return DeclPtrTy::make((Decl *)0);
4250
4251    DC = computeDeclContext(SS, true);
4252    SearchDC = DC;
4253    // Look-up name inside 'foo::'.
4254    LookupResult R;
4255    LookupQualifiedName(R, DC, Name, LookupTagName, RedeclarationOnly);
4256
4257    if (R.isAmbiguous()) {
4258      DiagnoseAmbiguousLookup(R, Name, NameLoc, SS.getRange());
4259      return DeclPtrTy();
4260    }
4261
4262    if (R.getKind() == LookupResult::Found)
4263      PrevDecl = dyn_cast<TagDecl>(R.getFoundDecl());
4264
4265    // A tag 'foo::bar' must already exist.
4266    if (!PrevDecl) {
4267      Diag(NameLoc, diag::err_not_tag_in_scope) << Name << SS.getRange();
4268      Name = 0;
4269      Invalid = true;
4270      goto CreateNewDecl;
4271    }
4272  } else if (Name) {
4273    // If this is a named struct, check to see if there was a previous forward
4274    // declaration or definition.
4275    // FIXME: We're looking into outer scopes here, even when we
4276    // shouldn't be. Doing so can result in ambiguities that we
4277    // shouldn't be diagnosing.
4278    LookupResult R;
4279    LookupName(R, S, Name, LookupTagName, RedeclarationOnly);
4280    if (R.isAmbiguous()) {
4281      DiagnoseAmbiguousLookup(R, Name, NameLoc);
4282      // FIXME: This is not best way to recover from case like:
4283      //
4284      // struct S s;
4285      //
4286      // causes needless "incomplete type" error later.
4287      Name = 0;
4288      PrevDecl = 0;
4289      Invalid = true;
4290    } else
4291      PrevDecl = R.getAsSingleDecl(Context);
4292
4293    if (!getLangOptions().CPlusPlus && TUK != TUK_Reference) {
4294      // FIXME: This makes sure that we ignore the contexts associated
4295      // with C structs, unions, and enums when looking for a matching
4296      // tag declaration or definition. See the similar lookup tweak
4297      // in Sema::LookupName; is there a better way to deal with this?
4298      while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
4299        SearchDC = SearchDC->getParent();
4300    }
4301  }
4302
4303  if (PrevDecl && PrevDecl->isTemplateParameter()) {
4304    // Maybe we will complain about the shadowed template parameter.
4305    DiagnoseTemplateParameterShadow(NameLoc, PrevDecl);
4306    // Just pretend that we didn't see the previous declaration.
4307    PrevDecl = 0;
4308  }
4309
4310  if (getLangOptions().CPlusPlus && Name && DC && StdNamespace &&
4311      DC->Equals(StdNamespace) && Name->isStr("bad_alloc")) {
4312    // This is a declaration of or a reference to "std::bad_alloc".
4313    isStdBadAlloc = true;
4314
4315    if (!PrevDecl && StdBadAlloc) {
4316      // std::bad_alloc has been implicitly declared (but made invisible to
4317      // name lookup). Fill in this implicit declaration as the previous
4318      // declaration, so that the declarations get chained appropriately.
4319      PrevDecl = StdBadAlloc;
4320    }
4321  }
4322
4323  if (PrevDecl) {
4324    // Check whether the previous declaration is usable.
4325    (void)DiagnoseUseOfDecl(PrevDecl, NameLoc);
4326
4327    if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
4328      // If this is a use of a previous tag, or if the tag is already declared
4329      // in the same scope (so that the definition/declaration completes or
4330      // rementions the tag), reuse the decl.
4331      if (TUK == TUK_Reference || TUK == TUK_Friend ||
4332          isDeclInScope(PrevDecl, SearchDC, S)) {
4333        // Make sure that this wasn't declared as an enum and now used as a
4334        // struct or something similar.
4335        if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, KWLoc, *Name)) {
4336          bool SafeToContinue
4337            = (PrevTagDecl->getTagKind() != TagDecl::TK_enum &&
4338               Kind != TagDecl::TK_enum);
4339          if (SafeToContinue)
4340            Diag(KWLoc, diag::err_use_with_wrong_tag)
4341              << Name
4342              << CodeModificationHint::CreateReplacement(SourceRange(KWLoc),
4343                                                  PrevTagDecl->getKindName());
4344          else
4345            Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
4346          Diag(PrevDecl->getLocation(), diag::note_previous_use);
4347
4348          if (SafeToContinue)
4349            Kind = PrevTagDecl->getTagKind();
4350          else {
4351            // Recover by making this an anonymous redefinition.
4352            Name = 0;
4353            PrevDecl = 0;
4354            Invalid = true;
4355          }
4356        }
4357
4358        if (!Invalid) {
4359          // If this is a use, just return the declaration we found.
4360
4361          // FIXME: In the future, return a variant or some other clue
4362          // for the consumer of this Decl to know it doesn't own it.
4363          // For our current ASTs this shouldn't be a problem, but will
4364          // need to be changed with DeclGroups.
4365          if (TUK == TUK_Reference || TUK == TUK_Friend)
4366            return DeclPtrTy::make(PrevDecl);
4367
4368          // Diagnose attempts to redefine a tag.
4369          if (TUK == TUK_Definition) {
4370            if (TagDecl *Def = PrevTagDecl->getDefinition(Context)) {
4371              // If we're defining a specialization and the previous definition
4372              // is from an implicit instantiation, don't emit an error
4373              // here; we'll catch this in the general case below.
4374              if (!isExplicitSpecialization ||
4375                  !isa<CXXRecordDecl>(Def) ||
4376                  cast<CXXRecordDecl>(Def)->getTemplateSpecializationKind()
4377                                               == TSK_ExplicitSpecialization) {
4378                Diag(NameLoc, diag::err_redefinition) << Name;
4379                Diag(Def->getLocation(), diag::note_previous_definition);
4380                // If this is a redefinition, recover by making this
4381                // struct be anonymous, which will make any later
4382                // references get the previous definition.
4383                Name = 0;
4384                PrevDecl = 0;
4385                Invalid = true;
4386              }
4387            } else {
4388              // If the type is currently being defined, complain
4389              // about a nested redefinition.
4390              TagType *Tag = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
4391              if (Tag->isBeingDefined()) {
4392                Diag(NameLoc, diag::err_nested_redefinition) << Name;
4393                Diag(PrevTagDecl->getLocation(),
4394                     diag::note_previous_definition);
4395                Name = 0;
4396                PrevDecl = 0;
4397                Invalid = true;
4398              }
4399            }
4400
4401            // Okay, this is definition of a previously declared or referenced
4402            // tag PrevDecl. We're going to create a new Decl for it.
4403          }
4404        }
4405        // If we get here we have (another) forward declaration or we
4406        // have a definition.  Just create a new decl.
4407
4408      } else {
4409        // If we get here, this is a definition of a new tag type in a nested
4410        // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
4411        // new decl/type.  We set PrevDecl to NULL so that the entities
4412        // have distinct types.
4413        PrevDecl = 0;
4414      }
4415      // If we get here, we're going to create a new Decl. If PrevDecl
4416      // is non-NULL, it's a definition of the tag declared by
4417      // PrevDecl. If it's NULL, we have a new definition.
4418    } else {
4419      // PrevDecl is a namespace, template, or anything else
4420      // that lives in the IDNS_Tag identifier namespace.
4421      if (isDeclInScope(PrevDecl, SearchDC, S)) {
4422        // The tag name clashes with a namespace name, issue an error and
4423        // recover by making this tag be anonymous.
4424        Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
4425        Diag(PrevDecl->getLocation(), diag::note_previous_definition);
4426        Name = 0;
4427        PrevDecl = 0;
4428        Invalid = true;
4429      } else {
4430        // The existing declaration isn't relevant to us; we're in a
4431        // new scope, so clear out the previous declaration.
4432        PrevDecl = 0;
4433      }
4434    }
4435  } else if (TUK == TUK_Reference && SS.isEmpty() && Name &&
4436             (Kind != TagDecl::TK_enum || !getLangOptions().CPlusPlus)) {
4437    // C++ [basic.scope.pdecl]p5:
4438    //   -- for an elaborated-type-specifier of the form
4439    //
4440    //          class-key identifier
4441    //
4442    //      if the elaborated-type-specifier is used in the
4443    //      decl-specifier-seq or parameter-declaration-clause of a
4444    //      function defined in namespace scope, the identifier is
4445    //      declared as a class-name in the namespace that contains
4446    //      the declaration; otherwise, except as a friend
4447    //      declaration, the identifier is declared in the smallest
4448    //      non-class, non-function-prototype scope that contains the
4449    //      declaration.
4450    //
4451    // C99 6.7.2.3p8 has a similar (but not identical!) provision for
4452    // C structs and unions.
4453    //
4454    // GNU C also supports this behavior as part of its incomplete
4455    // enum types extension, while GNU C++ does not.
4456    //
4457    // Find the context where we'll be declaring the tag.
4458    // FIXME: We would like to maintain the current DeclContext as the
4459    // lexical context,
4460    while (SearchDC->isRecord())
4461      SearchDC = SearchDC->getParent();
4462
4463    // Find the scope where we'll be declaring the tag.
4464    while (S->isClassScope() ||
4465           (getLangOptions().CPlusPlus && S->isFunctionPrototypeScope()) ||
4466           ((S->getFlags() & Scope::DeclScope) == 0) ||
4467           (S->getEntity() &&
4468            ((DeclContext *)S->getEntity())->isTransparentContext()))
4469      S = S->getParent();
4470
4471  } else if (TUK == TUK_Friend && SS.isEmpty() && Name) {
4472    // C++ [namespace.memdef]p3:
4473    //   If a friend declaration in a non-local class first declares a
4474    //   class or function, the friend class or function is a member of
4475    //   the innermost enclosing namespace.
4476    while (!SearchDC->isFileContext())
4477      SearchDC = SearchDC->getParent();
4478
4479    // The entity of a decl scope is a DeclContext; see PushDeclContext.
4480    while (S->getEntity() != SearchDC)
4481      S = S->getParent();
4482  }
4483
4484CreateNewDecl:
4485
4486  // If there is an identifier, use the location of the identifier as the
4487  // location of the decl, otherwise use the location of the struct/union
4488  // keyword.
4489  SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
4490
4491  // Otherwise, create a new declaration. If there is a previous
4492  // declaration of the same entity, the two will be linked via
4493  // PrevDecl.
4494  TagDecl *New;
4495
4496  if (Kind == TagDecl::TK_enum) {
4497    // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4498    // enum X { A, B, C } D;    D should chain to X.
4499    New = EnumDecl::Create(Context, SearchDC, Loc, Name, KWLoc,
4500                           cast_or_null<EnumDecl>(PrevDecl));
4501    // If this is an undefined enum, warn.
4502    if (TUK != TUK_Definition && !Invalid)  {
4503      unsigned DK = getLangOptions().CPlusPlus? diag::err_forward_ref_enum
4504                                              : diag::ext_forward_ref_enum;
4505      Diag(Loc, DK);
4506    }
4507  } else {
4508    // struct/union/class
4509
4510    // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
4511    // struct X { int A; } D;    D should chain to X.
4512    if (getLangOptions().CPlusPlus) {
4513      // FIXME: Look for a way to use RecordDecl for simple structs.
4514      New = CXXRecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4515                                  cast_or_null<CXXRecordDecl>(PrevDecl));
4516
4517      if (isStdBadAlloc && (!StdBadAlloc || StdBadAlloc->isImplicit()))
4518        StdBadAlloc = cast<CXXRecordDecl>(New);
4519    } else
4520      New = RecordDecl::Create(Context, Kind, SearchDC, Loc, Name, KWLoc,
4521                               cast_or_null<RecordDecl>(PrevDecl));
4522  }
4523
4524  if (Kind != TagDecl::TK_enum) {
4525    // Handle #pragma pack: if the #pragma pack stack has non-default
4526    // alignment, make up a packed attribute for this decl. These
4527    // attributes are checked when the ASTContext lays out the
4528    // structure.
4529    //
4530    // It is important for implementing the correct semantics that this
4531    // happen here (in act on tag decl). The #pragma pack stack is
4532    // maintained as a result of parser callbacks which can occur at
4533    // many points during the parsing of a struct declaration (because
4534    // the #pragma tokens are effectively skipped over during the
4535    // parsing of the struct).
4536    if (unsigned Alignment = getPragmaPackAlignment())
4537      New->addAttr(::new (Context) PragmaPackAttr(Alignment * 8));
4538  }
4539
4540  if (getLangOptions().CPlusPlus && SS.isEmpty() && Name && !Invalid) {
4541    // C++ [dcl.typedef]p3:
4542    //   [...] Similarly, in a given scope, a class or enumeration
4543    //   shall not be declared with the same name as a typedef-name
4544    //   that is declared in that scope and refers to a type other
4545    //   than the class or enumeration itself.
4546    LookupResult Lookup;
4547    LookupName(Lookup, S, Name, LookupOrdinaryName, true);
4548    TypedefDecl *PrevTypedef = 0;
4549    if (NamedDecl *Prev = Lookup.getAsSingleDecl(Context))
4550      PrevTypedef = dyn_cast<TypedefDecl>(Prev);
4551
4552    NamedDecl *PrevTypedefNamed = PrevTypedef;
4553    if (PrevTypedef && isDeclInScope(PrevTypedefNamed, SearchDC, S) &&
4554        Context.getCanonicalType(Context.getTypeDeclType(PrevTypedef)) !=
4555          Context.getCanonicalType(Context.getTypeDeclType(New))) {
4556      Diag(Loc, diag::err_tag_definition_of_typedef)
4557        << Context.getTypeDeclType(New)
4558        << PrevTypedef->getUnderlyingType();
4559      Diag(PrevTypedef->getLocation(), diag::note_previous_definition);
4560      Invalid = true;
4561    }
4562  }
4563
4564  // If this is a specialization of a member class (of a class template),
4565  // check the specialization.
4566  if (isExplicitSpecialization && CheckMemberSpecialization(New, PrevDecl))
4567    Invalid = true;
4568
4569  if (Invalid)
4570    New->setInvalidDecl();
4571
4572  if (Attr)
4573    ProcessDeclAttributeList(S, New, Attr);
4574
4575  // If we're declaring or defining a tag in function prototype scope
4576  // in C, note that this type can only be used within the function.
4577  if (Name && S->isFunctionPrototypeScope() && !getLangOptions().CPlusPlus)
4578    Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
4579
4580  // Set the lexical context. If the tag has a C++ scope specifier, the
4581  // lexical context will be different from the semantic context.
4582  New->setLexicalDeclContext(CurContext);
4583
4584  // Mark this as a friend decl if applicable.
4585  if (TUK == TUK_Friend)
4586    New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ PrevDecl != NULL);
4587
4588  // Set the access specifier.
4589  if (!Invalid && TUK != TUK_Friend)
4590    SetMemberAccessSpecifier(New, PrevDecl, AS);
4591
4592  if (TUK == TUK_Definition)
4593    New->startDefinition();
4594
4595  // If this has an identifier, add it to the scope stack.
4596  if (TUK == TUK_Friend) {
4597    // We might be replacing an existing declaration in the lookup tables;
4598    // if so, borrow its access specifier.
4599    if (PrevDecl)
4600      New->setAccess(PrevDecl->getAccess());
4601
4602    // Friend tag decls are visible in fairly strange ways.
4603    if (!CurContext->isDependentContext()) {
4604      DeclContext *DC = New->getDeclContext()->getLookupContext();
4605      DC->makeDeclVisibleInContext(New, /* Recoverable = */ false);
4606      if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
4607        PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
4608    }
4609  } else if (Name) {
4610    S = getNonFieldDeclScope(S);
4611    PushOnScopeChains(New, S);
4612  } else {
4613    CurContext->addDecl(New);
4614  }
4615
4616  // If this is the C FILE type, notify the AST context.
4617  if (IdentifierInfo *II = New->getIdentifier())
4618    if (!New->isInvalidDecl() &&
4619        New->getDeclContext()->getLookupContext()->isTranslationUnit() &&
4620        II->isStr("FILE"))
4621      Context.setFILEDecl(New);
4622
4623  OwnedDecl = true;
4624  return DeclPtrTy::make(New);
4625}
4626
4627void Sema::ActOnTagStartDefinition(Scope *S, DeclPtrTy TagD) {
4628  AdjustDeclIfTemplate(TagD);
4629  TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4630
4631  // Enter the tag context.
4632  PushDeclContext(S, Tag);
4633
4634  if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Tag)) {
4635    FieldCollector->StartClass();
4636
4637    if (Record->getIdentifier()) {
4638      // C++ [class]p2:
4639      //   [...] The class-name is also inserted into the scope of the
4640      //   class itself; this is known as the injected-class-name. For
4641      //   purposes of access checking, the injected-class-name is treated
4642      //   as if it were a public member name.
4643      CXXRecordDecl *InjectedClassName
4644        = CXXRecordDecl::Create(Context, Record->getTagKind(),
4645                                CurContext, Record->getLocation(),
4646                                Record->getIdentifier(),
4647                                Record->getTagKeywordLoc(),
4648                                Record);
4649      InjectedClassName->setImplicit();
4650      InjectedClassName->setAccess(AS_public);
4651      if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
4652        InjectedClassName->setDescribedClassTemplate(Template);
4653      PushOnScopeChains(InjectedClassName, S);
4654      assert(InjectedClassName->isInjectedClassName() &&
4655             "Broken injected-class-name");
4656    }
4657  }
4658}
4659
4660void Sema::ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagD,
4661                                    SourceLocation RBraceLoc) {
4662  AdjustDeclIfTemplate(TagD);
4663  TagDecl *Tag = cast<TagDecl>(TagD.getAs<Decl>());
4664  Tag->setRBraceLoc(RBraceLoc);
4665
4666  if (isa<CXXRecordDecl>(Tag))
4667    FieldCollector->FinishClass();
4668
4669  // Exit this scope of this tag's definition.
4670  PopDeclContext();
4671
4672  // Notify the consumer that we've defined a tag.
4673  Consumer.HandleTagDeclDefinition(Tag);
4674}
4675
4676// Note that FieldName may be null for anonymous bitfields.
4677bool Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
4678                          QualType FieldTy, const Expr *BitWidth,
4679                          bool *ZeroWidth) {
4680  // Default to true; that shouldn't confuse checks for emptiness
4681  if (ZeroWidth)
4682    *ZeroWidth = true;
4683
4684  // C99 6.7.2.1p4 - verify the field type.
4685  // C++ 9.6p3: A bit-field shall have integral or enumeration type.
4686  if (!FieldTy->isDependentType() && !FieldTy->isIntegralType()) {
4687    // Handle incomplete types with specific error.
4688    if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
4689      return true;
4690    if (FieldName)
4691      return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
4692        << FieldName << FieldTy << BitWidth->getSourceRange();
4693    return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
4694      << FieldTy << BitWidth->getSourceRange();
4695  }
4696
4697  // If the bit-width is type- or value-dependent, don't try to check
4698  // it now.
4699  if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
4700    return false;
4701
4702  llvm::APSInt Value;
4703  if (VerifyIntegerConstantExpression(BitWidth, &Value))
4704    return true;
4705
4706  if (Value != 0 && ZeroWidth)
4707    *ZeroWidth = false;
4708
4709  // Zero-width bitfield is ok for anonymous field.
4710  if (Value == 0 && FieldName)
4711    return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
4712
4713  if (Value.isSigned() && Value.isNegative()) {
4714    if (FieldName)
4715      return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
4716               << FieldName << Value.toString(10);
4717    return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
4718      << Value.toString(10);
4719  }
4720
4721  if (!FieldTy->isDependentType()) {
4722    uint64_t TypeSize = Context.getTypeSize(FieldTy);
4723    if (Value.getZExtValue() > TypeSize) {
4724      if (FieldName)
4725        return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
4726          << FieldName << (unsigned)TypeSize;
4727      return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
4728        << (unsigned)TypeSize;
4729    }
4730  }
4731
4732  return false;
4733}
4734
4735/// ActOnField - Each field of a struct/union/class is passed into this in order
4736/// to create a FieldDecl object for it.
4737Sema::DeclPtrTy Sema::ActOnField(Scope *S, DeclPtrTy TagD,
4738                                 SourceLocation DeclStart,
4739                                 Declarator &D, ExprTy *BitfieldWidth) {
4740  FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD.getAs<Decl>()),
4741                               DeclStart, D, static_cast<Expr*>(BitfieldWidth),
4742                               AS_public);
4743  return DeclPtrTy::make(Res);
4744}
4745
4746/// HandleField - Analyze a field of a C struct or a C++ data member.
4747///
4748FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
4749                             SourceLocation DeclStart,
4750                             Declarator &D, Expr *BitWidth,
4751                             AccessSpecifier AS) {
4752  IdentifierInfo *II = D.getIdentifier();
4753  SourceLocation Loc = DeclStart;
4754  if (II) Loc = D.getIdentifierLoc();
4755
4756  DeclaratorInfo *DInfo = 0;
4757  QualType T = GetTypeForDeclarator(D, S, &DInfo);
4758  if (getLangOptions().CPlusPlus)
4759    CheckExtraCXXDefaultArguments(D);
4760
4761  DiagnoseFunctionSpecifiers(D);
4762
4763  if (D.getDeclSpec().isThreadSpecified())
4764    Diag(D.getDeclSpec().getThreadSpecLoc(), diag::err_invalid_thread);
4765
4766  NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName, true);
4767
4768  if (PrevDecl && PrevDecl->isTemplateParameter()) {
4769    // Maybe we will complain about the shadowed template parameter.
4770    DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
4771    // Just pretend that we didn't see the previous declaration.
4772    PrevDecl = 0;
4773  }
4774
4775  if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
4776    PrevDecl = 0;
4777
4778  bool Mutable
4779    = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
4780  SourceLocation TSSL = D.getSourceRange().getBegin();
4781  FieldDecl *NewFD
4782    = CheckFieldDecl(II, T, DInfo, Record, Loc, Mutable, BitWidth, TSSL,
4783                     AS, PrevDecl, &D);
4784  if (NewFD->isInvalidDecl() && PrevDecl) {
4785    // Don't introduce NewFD into scope; there's already something
4786    // with the same name in the same scope.
4787  } else if (II) {
4788    PushOnScopeChains(NewFD, S);
4789  } else
4790    Record->addDecl(NewFD);
4791
4792  return NewFD;
4793}
4794
4795/// \brief Build a new FieldDecl and check its well-formedness.
4796///
4797/// This routine builds a new FieldDecl given the fields name, type,
4798/// record, etc. \p PrevDecl should refer to any previous declaration
4799/// with the same name and in the same scope as the field to be
4800/// created.
4801///
4802/// \returns a new FieldDecl.
4803///
4804/// \todo The Declarator argument is a hack. It will be removed once
4805FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
4806                                DeclaratorInfo *DInfo,
4807                                RecordDecl *Record, SourceLocation Loc,
4808                                bool Mutable, Expr *BitWidth,
4809                                SourceLocation TSSL,
4810                                AccessSpecifier AS, NamedDecl *PrevDecl,
4811                                Declarator *D) {
4812  IdentifierInfo *II = Name.getAsIdentifierInfo();
4813  bool InvalidDecl = false;
4814  if (D) InvalidDecl = D->isInvalidType();
4815
4816  // If we receive a broken type, recover by assuming 'int' and
4817  // marking this declaration as invalid.
4818  if (T.isNull()) {
4819    InvalidDecl = true;
4820    T = Context.IntTy;
4821  }
4822
4823  // C99 6.7.2.1p8: A member of a structure or union may have any type other
4824  // than a variably modified type.
4825  if (T->isVariablyModifiedType()) {
4826    bool SizeIsNegative;
4827    QualType FixedTy = TryToFixInvalidVariablyModifiedType(T, Context,
4828                                                           SizeIsNegative);
4829    if (!FixedTy.isNull()) {
4830      Diag(Loc, diag::warn_illegal_constant_array_size);
4831      T = FixedTy;
4832    } else {
4833      if (SizeIsNegative)
4834        Diag(Loc, diag::err_typecheck_negative_array_size);
4835      else
4836        Diag(Loc, diag::err_typecheck_field_variable_size);
4837      InvalidDecl = true;
4838    }
4839  }
4840
4841  // Fields can not have abstract class types
4842  if (RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl,
4843                             AbstractFieldType))
4844    InvalidDecl = true;
4845
4846  bool ZeroWidth = false;
4847  // If this is declared as a bit-field, check the bit-field.
4848  if (BitWidth && VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth)) {
4849    InvalidDecl = true;
4850    DeleteExpr(BitWidth);
4851    BitWidth = 0;
4852    ZeroWidth = false;
4853  }
4854
4855  FieldDecl *NewFD = FieldDecl::Create(Context, Record, Loc, II, T, DInfo,
4856                                       BitWidth, Mutable);
4857  if (InvalidDecl)
4858    NewFD->setInvalidDecl();
4859
4860  if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
4861    Diag(Loc, diag::err_duplicate_member) << II;
4862    Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
4863    NewFD->setInvalidDecl();
4864  }
4865
4866  if (getLangOptions().CPlusPlus) {
4867    QualType EltTy = Context.getBaseElementType(T);
4868
4869    CXXRecordDecl* CXXRecord = cast<CXXRecordDecl>(Record);
4870
4871    if (!T->isPODType())
4872      CXXRecord->setPOD(false);
4873    if (!ZeroWidth)
4874      CXXRecord->setEmpty(false);
4875
4876    if (const RecordType *RT = EltTy->getAs<RecordType>()) {
4877      CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
4878
4879      if (!RDecl->hasTrivialConstructor())
4880        CXXRecord->setHasTrivialConstructor(false);
4881      if (!RDecl->hasTrivialCopyConstructor())
4882        CXXRecord->setHasTrivialCopyConstructor(false);
4883      if (!RDecl->hasTrivialCopyAssignment())
4884        CXXRecord->setHasTrivialCopyAssignment(false);
4885      if (!RDecl->hasTrivialDestructor())
4886        CXXRecord->setHasTrivialDestructor(false);
4887
4888      // C++ 9.5p1: An object of a class with a non-trivial
4889      // constructor, a non-trivial copy constructor, a non-trivial
4890      // destructor, or a non-trivial copy assignment operator
4891      // cannot be a member of a union, nor can an array of such
4892      // objects.
4893      // TODO: C++0x alters this restriction significantly.
4894      if (Record->isUnion()) {
4895        // We check for copy constructors before constructors
4896        // because otherwise we'll never get complaints about
4897        // copy constructors.
4898
4899        const CXXSpecialMember invalid = (CXXSpecialMember) -1;
4900
4901        CXXSpecialMember member;
4902        if (!RDecl->hasTrivialCopyConstructor())
4903          member = CXXCopyConstructor;
4904        else if (!RDecl->hasTrivialConstructor())
4905          member = CXXDefaultConstructor;
4906        else if (!RDecl->hasTrivialCopyAssignment())
4907          member = CXXCopyAssignment;
4908        else if (!RDecl->hasTrivialDestructor())
4909          member = CXXDestructor;
4910        else
4911          member = invalid;
4912
4913        if (member != invalid) {
4914          Diag(Loc, diag::err_illegal_union_member) << Name << member;
4915          DiagnoseNontrivial(RT, member);
4916          NewFD->setInvalidDecl();
4917        }
4918      }
4919    }
4920  }
4921
4922  // FIXME: We need to pass in the attributes given an AST
4923  // representation, not a parser representation.
4924  if (D)
4925    // FIXME: What to pass instead of TUScope?
4926    ProcessDeclAttributes(TUScope, NewFD, *D);
4927
4928  if (T.isObjCGCWeak())
4929    Diag(Loc, diag::warn_attribute_weak_on_field);
4930
4931  NewFD->setAccess(AS);
4932
4933  // C++ [dcl.init.aggr]p1:
4934  //   An aggregate is an array or a class (clause 9) with [...] no
4935  //   private or protected non-static data members (clause 11).
4936  // A POD must be an aggregate.
4937  if (getLangOptions().CPlusPlus &&
4938      (AS == AS_private || AS == AS_protected)) {
4939    CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
4940    CXXRecord->setAggregate(false);
4941    CXXRecord->setPOD(false);
4942  }
4943
4944  return NewFD;
4945}
4946
4947/// DiagnoseNontrivial - Given that a class has a non-trivial
4948/// special member, figure out why.
4949void Sema::DiagnoseNontrivial(const RecordType* T, CXXSpecialMember member) {
4950  QualType QT(T, 0U);
4951  CXXRecordDecl* RD = cast<CXXRecordDecl>(T->getDecl());
4952
4953  // Check whether the member was user-declared.
4954  switch (member) {
4955  case CXXDefaultConstructor:
4956    if (RD->hasUserDeclaredConstructor()) {
4957      typedef CXXRecordDecl::ctor_iterator ctor_iter;
4958      for (ctor_iter ci = RD->ctor_begin(), ce = RD->ctor_end(); ci != ce; ++ci)
4959        if (!ci->isImplicitlyDefined(Context)) {
4960          SourceLocation CtorLoc = ci->getLocation();
4961          Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
4962          return;
4963        }
4964
4965      assert(0 && "found no user-declared constructors");
4966      return;
4967    }
4968    break;
4969
4970  case CXXCopyConstructor:
4971    if (RD->hasUserDeclaredCopyConstructor()) {
4972      SourceLocation CtorLoc =
4973        RD->getCopyConstructor(Context, 0)->getLocation();
4974      Diag(CtorLoc, diag::note_nontrivial_user_defined) << QT << member;
4975      return;
4976    }
4977    break;
4978
4979  case CXXCopyAssignment:
4980    if (RD->hasUserDeclaredCopyAssignment()) {
4981      // FIXME: this should use the location of the copy
4982      // assignment, not the type.
4983      SourceLocation TyLoc = RD->getSourceRange().getBegin();
4984      Diag(TyLoc, diag::note_nontrivial_user_defined) << QT << member;
4985      return;
4986    }
4987    break;
4988
4989  case CXXDestructor:
4990    if (RD->hasUserDeclaredDestructor()) {
4991      SourceLocation DtorLoc = RD->getDestructor(Context)->getLocation();
4992      Diag(DtorLoc, diag::note_nontrivial_user_defined) << QT << member;
4993      return;
4994    }
4995    break;
4996  }
4997
4998  typedef CXXRecordDecl::base_class_iterator base_iter;
4999
5000  // Virtual bases and members inhibit trivial copying/construction,
5001  // but not trivial destruction.
5002  if (member != CXXDestructor) {
5003    // Check for virtual bases.  vbases includes indirect virtual bases,
5004    // so we just iterate through the direct bases.
5005    for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi)
5006      if (bi->isVirtual()) {
5007        SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5008        Diag(BaseLoc, diag::note_nontrivial_has_virtual) << QT << 1;
5009        return;
5010      }
5011
5012    // Check for virtual methods.
5013    typedef CXXRecordDecl::method_iterator meth_iter;
5014    for (meth_iter mi = RD->method_begin(), me = RD->method_end(); mi != me;
5015         ++mi) {
5016      if (mi->isVirtual()) {
5017        SourceLocation MLoc = mi->getSourceRange().getBegin();
5018        Diag(MLoc, diag::note_nontrivial_has_virtual) << QT << 0;
5019        return;
5020      }
5021    }
5022  }
5023
5024  bool (CXXRecordDecl::*hasTrivial)() const;
5025  switch (member) {
5026  case CXXDefaultConstructor:
5027    hasTrivial = &CXXRecordDecl::hasTrivialConstructor; break;
5028  case CXXCopyConstructor:
5029    hasTrivial = &CXXRecordDecl::hasTrivialCopyConstructor; break;
5030  case CXXCopyAssignment:
5031    hasTrivial = &CXXRecordDecl::hasTrivialCopyAssignment; break;
5032  case CXXDestructor:
5033    hasTrivial = &CXXRecordDecl::hasTrivialDestructor; break;
5034  default:
5035    assert(0 && "unexpected special member"); return;
5036  }
5037
5038  // Check for nontrivial bases (and recurse).
5039  for (base_iter bi = RD->bases_begin(), be = RD->bases_end(); bi != be; ++bi) {
5040    const RecordType *BaseRT = bi->getType()->getAs<RecordType>();
5041    assert(BaseRT);
5042    CXXRecordDecl *BaseRecTy = cast<CXXRecordDecl>(BaseRT->getDecl());
5043    if (!(BaseRecTy->*hasTrivial)()) {
5044      SourceLocation BaseLoc = bi->getSourceRange().getBegin();
5045      Diag(BaseLoc, diag::note_nontrivial_has_nontrivial) << QT << 1 << member;
5046      DiagnoseNontrivial(BaseRT, member);
5047      return;
5048    }
5049  }
5050
5051  // Check for nontrivial members (and recurse).
5052  typedef RecordDecl::field_iterator field_iter;
5053  for (field_iter fi = RD->field_begin(), fe = RD->field_end(); fi != fe;
5054       ++fi) {
5055    QualType EltTy = Context.getBaseElementType((*fi)->getType());
5056    if (const RecordType *EltRT = EltTy->getAs<RecordType>()) {
5057      CXXRecordDecl* EltRD = cast<CXXRecordDecl>(EltRT->getDecl());
5058
5059      if (!(EltRD->*hasTrivial)()) {
5060        SourceLocation FLoc = (*fi)->getLocation();
5061        Diag(FLoc, diag::note_nontrivial_has_nontrivial) << QT << 0 << member;
5062        DiagnoseNontrivial(EltRT, member);
5063        return;
5064      }
5065    }
5066  }
5067
5068  assert(0 && "found no explanation for non-trivial member");
5069}
5070
5071/// TranslateIvarVisibility - Translate visibility from a token ID to an
5072///  AST enum value.
5073static ObjCIvarDecl::AccessControl
5074TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
5075  switch (ivarVisibility) {
5076  default: assert(0 && "Unknown visitibility kind");
5077  case tok::objc_private: return ObjCIvarDecl::Private;
5078  case tok::objc_public: return ObjCIvarDecl::Public;
5079  case tok::objc_protected: return ObjCIvarDecl::Protected;
5080  case tok::objc_package: return ObjCIvarDecl::Package;
5081  }
5082}
5083
5084/// ActOnIvar - Each ivar field of an objective-c class is passed into this
5085/// in order to create an IvarDecl object for it.
5086Sema::DeclPtrTy Sema::ActOnIvar(Scope *S,
5087                                SourceLocation DeclStart,
5088                                DeclPtrTy IntfDecl,
5089                                Declarator &D, ExprTy *BitfieldWidth,
5090                                tok::ObjCKeywordKind Visibility) {
5091
5092  IdentifierInfo *II = D.getIdentifier();
5093  Expr *BitWidth = (Expr*)BitfieldWidth;
5094  SourceLocation Loc = DeclStart;
5095  if (II) Loc = D.getIdentifierLoc();
5096
5097  // FIXME: Unnamed fields can be handled in various different ways, for
5098  // example, unnamed unions inject all members into the struct namespace!
5099
5100  DeclaratorInfo *DInfo = 0;
5101  QualType T = GetTypeForDeclarator(D, S, &DInfo);
5102
5103  if (BitWidth) {
5104    // 6.7.2.1p3, 6.7.2.1p4
5105    if (VerifyBitField(Loc, II, T, BitWidth)) {
5106      D.setInvalidType();
5107      DeleteExpr(BitWidth);
5108      BitWidth = 0;
5109    }
5110  } else {
5111    // Not a bitfield.
5112
5113    // validate II.
5114
5115  }
5116
5117  // C99 6.7.2.1p8: A member of a structure or union may have any type other
5118  // than a variably modified type.
5119  if (T->isVariablyModifiedType()) {
5120    Diag(Loc, diag::err_typecheck_ivar_variable_size);
5121    D.setInvalidType();
5122  }
5123
5124  // Get the visibility (access control) for this ivar.
5125  ObjCIvarDecl::AccessControl ac =
5126    Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
5127                                        : ObjCIvarDecl::None;
5128  // Must set ivar's DeclContext to its enclosing interface.
5129  Decl *EnclosingDecl = IntfDecl.getAs<Decl>();
5130  DeclContext *EnclosingContext;
5131  if (ObjCImplementationDecl *IMPDecl =
5132      dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5133    // Case of ivar declared in an implementation. Context is that of its class.
5134    ObjCInterfaceDecl* IDecl = IMPDecl->getClassInterface();
5135    assert(IDecl && "No class- ActOnIvar");
5136    EnclosingContext = cast_or_null<DeclContext>(IDecl);
5137  } else
5138    EnclosingContext = dyn_cast<DeclContext>(EnclosingDecl);
5139  assert(EnclosingContext && "null DeclContext for ivar - ActOnIvar");
5140
5141  // Construct the decl.
5142  ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context,
5143                                             EnclosingContext, Loc, II, T,
5144                                             DInfo, ac, (Expr *)BitfieldWidth);
5145
5146  if (II) {
5147    NamedDecl *PrevDecl = LookupSingleName(S, II, LookupMemberName, true);
5148    if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
5149        && !isa<TagDecl>(PrevDecl)) {
5150      Diag(Loc, diag::err_duplicate_member) << II;
5151      Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
5152      NewID->setInvalidDecl();
5153    }
5154  }
5155
5156  // Process attributes attached to the ivar.
5157  ProcessDeclAttributes(S, NewID, D);
5158
5159  if (D.isInvalidType())
5160    NewID->setInvalidDecl();
5161
5162  if (II) {
5163    // FIXME: When interfaces are DeclContexts, we'll need to add
5164    // these to the interface.
5165    S->AddDecl(DeclPtrTy::make(NewID));
5166    IdResolver.AddDecl(NewID);
5167  }
5168
5169  return DeclPtrTy::make(NewID);
5170}
5171
5172void Sema::ActOnFields(Scope* S,
5173                       SourceLocation RecLoc, DeclPtrTy RecDecl,
5174                       DeclPtrTy *Fields, unsigned NumFields,
5175                       SourceLocation LBrac, SourceLocation RBrac,
5176                       AttributeList *Attr) {
5177  Decl *EnclosingDecl = RecDecl.getAs<Decl>();
5178  assert(EnclosingDecl && "missing record or interface decl");
5179
5180  // If the decl this is being inserted into is invalid, then it may be a
5181  // redeclaration or some other bogus case.  Don't try to add fields to it.
5182  if (EnclosingDecl->isInvalidDecl()) {
5183    // FIXME: Deallocate fields?
5184    return;
5185  }
5186
5187
5188  // Verify that all the fields are okay.
5189  unsigned NumNamedMembers = 0;
5190  llvm::SmallVector<FieldDecl*, 32> RecFields;
5191
5192  RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
5193  for (unsigned i = 0; i != NumFields; ++i) {
5194    FieldDecl *FD = cast<FieldDecl>(Fields[i].getAs<Decl>());
5195
5196    // Get the type for the field.
5197    Type *FDTy = FD->getType().getTypePtr();
5198
5199    if (!FD->isAnonymousStructOrUnion()) {
5200      // Remember all fields written by the user.
5201      RecFields.push_back(FD);
5202    }
5203
5204    // If the field is already invalid for some reason, don't emit more
5205    // diagnostics about it.
5206    if (FD->isInvalidDecl())
5207      continue;
5208
5209    // C99 6.7.2.1p2:
5210    //   A structure or union shall not contain a member with
5211    //   incomplete or function type (hence, a structure shall not
5212    //   contain an instance of itself, but may contain a pointer to
5213    //   an instance of itself), except that the last member of a
5214    //   structure with more than one named member may have incomplete
5215    //   array type; such a structure (and any union containing,
5216    //   possibly recursively, a member that is such a structure)
5217    //   shall not be a member of a structure or an element of an
5218    //   array.
5219    if (FDTy->isFunctionType()) {
5220      // Field declared as a function.
5221      Diag(FD->getLocation(), diag::err_field_declared_as_function)
5222        << FD->getDeclName();
5223      FD->setInvalidDecl();
5224      EnclosingDecl->setInvalidDecl();
5225      continue;
5226    } else if (FDTy->isIncompleteArrayType() && i == NumFields - 1 &&
5227               Record && Record->isStruct()) {
5228      // Flexible array member.
5229      if (NumNamedMembers < 1) {
5230        Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
5231          << FD->getDeclName();
5232        FD->setInvalidDecl();
5233        EnclosingDecl->setInvalidDecl();
5234        continue;
5235      }
5236      // Okay, we have a legal flexible array member at the end of the struct.
5237      if (Record)
5238        Record->setHasFlexibleArrayMember(true);
5239    } else if (!FDTy->isDependentType() &&
5240               RequireCompleteType(FD->getLocation(), FD->getType(),
5241                                   diag::err_field_incomplete)) {
5242      // Incomplete type
5243      FD->setInvalidDecl();
5244      EnclosingDecl->setInvalidDecl();
5245      continue;
5246    } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
5247      if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
5248        // If this is a member of a union, then entire union becomes "flexible".
5249        if (Record && Record->isUnion()) {
5250          Record->setHasFlexibleArrayMember(true);
5251        } else {
5252          // If this is a struct/class and this is not the last element, reject
5253          // it.  Note that GCC supports variable sized arrays in the middle of
5254          // structures.
5255          if (i != NumFields-1)
5256            Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
5257              << FD->getDeclName() << FD->getType();
5258          else {
5259            // We support flexible arrays at the end of structs in
5260            // other structs as an extension.
5261            Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
5262              << FD->getDeclName();
5263            if (Record)
5264              Record->setHasFlexibleArrayMember(true);
5265          }
5266        }
5267      }
5268      if (Record && FDTTy->getDecl()->hasObjectMember())
5269        Record->setHasObjectMember(true);
5270    } else if (FDTy->isObjCInterfaceType()) {
5271      /// A field cannot be an Objective-c object
5272      Diag(FD->getLocation(), diag::err_statically_allocated_object);
5273      FD->setInvalidDecl();
5274      EnclosingDecl->setInvalidDecl();
5275      continue;
5276    } else if (getLangOptions().ObjC1 &&
5277               getLangOptions().getGCMode() != LangOptions::NonGC &&
5278               Record &&
5279               (FD->getType()->isObjCObjectPointerType() ||
5280                FD->getType().isObjCGCStrong()))
5281      Record->setHasObjectMember(true);
5282    // Keep track of the number of named members.
5283    if (FD->getIdentifier())
5284      ++NumNamedMembers;
5285  }
5286
5287  // Okay, we successfully defined 'Record'.
5288  if (Record) {
5289    Record->completeDefinition(Context);
5290  } else {
5291    ObjCIvarDecl **ClsFields =
5292      reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
5293    if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
5294      ID->setIVarList(ClsFields, RecFields.size(), Context);
5295      ID->setLocEnd(RBrac);
5296      // Add ivar's to class's DeclContext.
5297      for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
5298        ClsFields[i]->setLexicalDeclContext(ID);
5299        ID->addDecl(ClsFields[i]);
5300      }
5301      // Must enforce the rule that ivars in the base classes may not be
5302      // duplicates.
5303      if (ID->getSuperClass()) {
5304        for (ObjCInterfaceDecl::ivar_iterator IVI = ID->ivar_begin(),
5305             IVE = ID->ivar_end(); IVI != IVE; ++IVI) {
5306          ObjCIvarDecl* Ivar = (*IVI);
5307
5308          if (IdentifierInfo *II = Ivar->getIdentifier()) {
5309            ObjCIvarDecl* prevIvar =
5310              ID->getSuperClass()->lookupInstanceVariable(II);
5311            if (prevIvar) {
5312              Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
5313              Diag(prevIvar->getLocation(), diag::note_previous_declaration);
5314            }
5315          }
5316        }
5317      }
5318    } else if (ObjCImplementationDecl *IMPDecl =
5319                  dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
5320      assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
5321      for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
5322        // Ivar declared in @implementation never belongs to the implementation.
5323        // Only it is in implementation's lexical context.
5324        ClsFields[I]->setLexicalDeclContext(IMPDecl);
5325      CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
5326    }
5327  }
5328
5329  if (Attr)
5330    ProcessDeclAttributeList(S, Record, Attr);
5331}
5332
5333EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
5334                                          EnumConstantDecl *LastEnumConst,
5335                                          SourceLocation IdLoc,
5336                                          IdentifierInfo *Id,
5337                                          ExprArg val) {
5338  Expr *Val = (Expr *)val.get();
5339
5340  llvm::APSInt EnumVal(32);
5341  QualType EltTy;
5342  if (Val && !Val->isTypeDependent()) {
5343    // Make sure to promote the operand type to int.
5344    UsualUnaryConversions(Val);
5345    if (Val != val.get()) {
5346      val.release();
5347      val = Val;
5348    }
5349
5350    // C99 6.7.2.2p2: Make sure we have an integer constant expression.
5351    SourceLocation ExpLoc;
5352    if (!Val->isValueDependent() &&
5353        VerifyIntegerConstantExpression(Val, &EnumVal)) {
5354      Val = 0;
5355    } else {
5356      EltTy = Val->getType();
5357    }
5358  }
5359
5360  if (!Val) {
5361    if (LastEnumConst) {
5362      // Assign the last value + 1.
5363      EnumVal = LastEnumConst->getInitVal();
5364      ++EnumVal;
5365
5366      // Check for overflow on increment.
5367      if (EnumVal < LastEnumConst->getInitVal())
5368        Diag(IdLoc, diag::warn_enum_value_overflow);
5369
5370      EltTy = LastEnumConst->getType();
5371    } else {
5372      // First value, set to zero.
5373      EltTy = Context.IntTy;
5374      EnumVal.zextOrTrunc(static_cast<uint32_t>(Context.getTypeSize(EltTy)));
5375    }
5376  }
5377
5378  val.release();
5379  return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
5380                                  Val, EnumVal);
5381}
5382
5383
5384Sema::DeclPtrTy Sema::ActOnEnumConstant(Scope *S, DeclPtrTy theEnumDecl,
5385                                        DeclPtrTy lastEnumConst,
5386                                        SourceLocation IdLoc,
5387                                        IdentifierInfo *Id,
5388                                        SourceLocation EqualLoc, ExprTy *val) {
5389  EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl.getAs<Decl>());
5390  EnumConstantDecl *LastEnumConst =
5391    cast_or_null<EnumConstantDecl>(lastEnumConst.getAs<Decl>());
5392  Expr *Val = static_cast<Expr*>(val);
5393
5394  // The scope passed in may not be a decl scope.  Zip up the scope tree until
5395  // we find one that is.
5396  S = getNonFieldDeclScope(S);
5397
5398  // Verify that there isn't already something declared with this name in this
5399  // scope.
5400  NamedDecl *PrevDecl = LookupSingleName(S, Id, LookupOrdinaryName);
5401  if (PrevDecl && PrevDecl->isTemplateParameter()) {
5402    // Maybe we will complain about the shadowed template parameter.
5403    DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
5404    // Just pretend that we didn't see the previous declaration.
5405    PrevDecl = 0;
5406  }
5407
5408  if (PrevDecl) {
5409    // When in C++, we may get a TagDecl with the same name; in this case the
5410    // enum constant will 'hide' the tag.
5411    assert((getLangOptions().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
5412           "Received TagDecl when not in C++!");
5413    if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
5414      if (isa<EnumConstantDecl>(PrevDecl))
5415        Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
5416      else
5417        Diag(IdLoc, diag::err_redefinition) << Id;
5418      Diag(PrevDecl->getLocation(), diag::note_previous_definition);
5419      if (Val) Val->Destroy(Context);
5420      return DeclPtrTy();
5421    }
5422  }
5423
5424  EnumConstantDecl *New = CheckEnumConstant(TheEnumDecl, LastEnumConst,
5425                                            IdLoc, Id, Owned(Val));
5426
5427  // Register this decl in the current scope stack.
5428  if (New)
5429    PushOnScopeChains(New, S);
5430
5431  return DeclPtrTy::make(New);
5432}
5433
5434void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
5435                         SourceLocation RBraceLoc, DeclPtrTy EnumDeclX,
5436                         DeclPtrTy *Elements, unsigned NumElements,
5437                         Scope *S, AttributeList *Attr) {
5438  EnumDecl *Enum = cast<EnumDecl>(EnumDeclX.getAs<Decl>());
5439  QualType EnumType = Context.getTypeDeclType(Enum);
5440
5441  if (Attr)
5442    ProcessDeclAttributeList(S, Enum, Attr);
5443
5444  // TODO: If the result value doesn't fit in an int, it must be a long or long
5445  // long value.  ISO C does not support this, but GCC does as an extension,
5446  // emit a warning.
5447  unsigned IntWidth = Context.Target.getIntWidth();
5448  unsigned CharWidth = Context.Target.getCharWidth();
5449  unsigned ShortWidth = Context.Target.getShortWidth();
5450
5451  // Verify that all the values are okay, compute the size of the values, and
5452  // reverse the list.
5453  unsigned NumNegativeBits = 0;
5454  unsigned NumPositiveBits = 0;
5455
5456  // Keep track of whether all elements have type int.
5457  bool AllElementsInt = true;
5458
5459  for (unsigned i = 0; i != NumElements; ++i) {
5460    EnumConstantDecl *ECD =
5461      cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5462    if (!ECD) continue;  // Already issued a diagnostic.
5463
5464    // If the enum value doesn't fit in an int, emit an extension warning.
5465    const llvm::APSInt &InitVal = ECD->getInitVal();
5466    assert(InitVal.getBitWidth() >= IntWidth &&
5467           "Should have promoted value to int");
5468    if (InitVal.getBitWidth() > IntWidth) {
5469      llvm::APSInt V(InitVal);
5470      V.trunc(IntWidth);
5471      V.extend(InitVal.getBitWidth());
5472      if (V != InitVal)
5473        Diag(ECD->getLocation(), diag::ext_enum_value_not_int)
5474          << InitVal.toString(10);
5475    }
5476
5477    // Keep track of the size of positive and negative values.
5478    if (InitVal.isUnsigned() || InitVal.isNonNegative())
5479      NumPositiveBits = std::max(NumPositiveBits,
5480                                 (unsigned)InitVal.getActiveBits());
5481    else
5482      NumNegativeBits = std::max(NumNegativeBits,
5483                                 (unsigned)InitVal.getMinSignedBits());
5484
5485    // Keep track of whether every enum element has type int (very commmon).
5486    if (AllElementsInt)
5487      AllElementsInt = ECD->getType() == Context.IntTy;
5488  }
5489
5490  // Figure out the type that should be used for this enum.
5491  // FIXME: Support -fshort-enums.
5492  QualType BestType;
5493  unsigned BestWidth;
5494
5495  bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
5496
5497  if (NumNegativeBits) {
5498    // If there is a negative value, figure out the smallest integer type (of
5499    // int/long/longlong) that fits.
5500    // If it's packed, check also if it fits a char or a short.
5501    if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
5502        BestType = Context.SignedCharTy;
5503        BestWidth = CharWidth;
5504    } else if (Packed && NumNegativeBits <= ShortWidth &&
5505               NumPositiveBits < ShortWidth) {
5506        BestType = Context.ShortTy;
5507        BestWidth = ShortWidth;
5508    }
5509    else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
5510      BestType = Context.IntTy;
5511      BestWidth = IntWidth;
5512    } else {
5513      BestWidth = Context.Target.getLongWidth();
5514
5515      if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth)
5516        BestType = Context.LongTy;
5517      else {
5518        BestWidth = Context.Target.getLongLongWidth();
5519
5520        if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
5521          Diag(Enum->getLocation(), diag::warn_enum_too_large);
5522        BestType = Context.LongLongTy;
5523      }
5524    }
5525  } else {
5526    // If there is no negative value, figure out which of uint, ulong, ulonglong
5527    // fits.
5528    // If it's packed, check also if it fits a char or a short.
5529    if (Packed && NumPositiveBits <= CharWidth) {
5530        BestType = Context.UnsignedCharTy;
5531        BestWidth = CharWidth;
5532    } else if (Packed && NumPositiveBits <= ShortWidth) {
5533        BestType = Context.UnsignedShortTy;
5534        BestWidth = ShortWidth;
5535    }
5536    else if (NumPositiveBits <= IntWidth) {
5537      BestType = Context.UnsignedIntTy;
5538      BestWidth = IntWidth;
5539    } else if (NumPositiveBits <=
5540               (BestWidth = Context.Target.getLongWidth())) {
5541      BestType = Context.UnsignedLongTy;
5542    } else {
5543      BestWidth = Context.Target.getLongLongWidth();
5544      assert(NumPositiveBits <= BestWidth &&
5545             "How could an initializer get larger than ULL?");
5546      BestType = Context.UnsignedLongLongTy;
5547    }
5548  }
5549
5550  // Loop over all of the enumerator constants, changing their types to match
5551  // the type of the enum if needed.
5552  for (unsigned i = 0; i != NumElements; ++i) {
5553    EnumConstantDecl *ECD =
5554      cast_or_null<EnumConstantDecl>(Elements[i].getAs<Decl>());
5555    if (!ECD) continue;  // Already issued a diagnostic.
5556
5557    // Standard C says the enumerators have int type, but we allow, as an
5558    // extension, the enumerators to be larger than int size.  If each
5559    // enumerator value fits in an int, type it as an int, otherwise type it the
5560    // same as the enumerator decl itself.  This means that in "enum { X = 1U }"
5561    // that X has type 'int', not 'unsigned'.
5562    if (ECD->getType() == Context.IntTy) {
5563      // Make sure the init value is signed.
5564      llvm::APSInt IV = ECD->getInitVal();
5565      IV.setIsSigned(true);
5566      ECD->setInitVal(IV);
5567
5568      if (getLangOptions().CPlusPlus)
5569        // C++ [dcl.enum]p4: Following the closing brace of an
5570        // enum-specifier, each enumerator has the type of its
5571        // enumeration.
5572        ECD->setType(EnumType);
5573      continue;  // Already int type.
5574    }
5575
5576    // Determine whether the value fits into an int.
5577    llvm::APSInt InitVal = ECD->getInitVal();
5578    bool FitsInInt;
5579    if (InitVal.isUnsigned() || !InitVal.isNegative())
5580      FitsInInt = InitVal.getActiveBits() < IntWidth;
5581    else
5582      FitsInInt = InitVal.getMinSignedBits() <= IntWidth;
5583
5584    // If it fits into an integer type, force it.  Otherwise force it to match
5585    // the enum decl type.
5586    QualType NewTy;
5587    unsigned NewWidth;
5588    bool NewSign;
5589    if (FitsInInt) {
5590      NewTy = Context.IntTy;
5591      NewWidth = IntWidth;
5592      NewSign = true;
5593    } else if (ECD->getType() == BestType) {
5594      // Already the right type!
5595      if (getLangOptions().CPlusPlus)
5596        // C++ [dcl.enum]p4: Following the closing brace of an
5597        // enum-specifier, each enumerator has the type of its
5598        // enumeration.
5599        ECD->setType(EnumType);
5600      continue;
5601    } else {
5602      NewTy = BestType;
5603      NewWidth = BestWidth;
5604      NewSign = BestType->isSignedIntegerType();
5605    }
5606
5607    // Adjust the APSInt value.
5608    InitVal.extOrTrunc(NewWidth);
5609    InitVal.setIsSigned(NewSign);
5610    ECD->setInitVal(InitVal);
5611
5612    // Adjust the Expr initializer and type.
5613    if (ECD->getInitExpr())
5614      ECD->setInitExpr(new (Context) ImplicitCastExpr(NewTy,
5615                                                      CastExpr::CK_IntegralCast,
5616                                                      ECD->getInitExpr(),
5617                                                      /*isLvalue=*/false));
5618    if (getLangOptions().CPlusPlus)
5619      // C++ [dcl.enum]p4: Following the closing brace of an
5620      // enum-specifier, each enumerator has the type of its
5621      // enumeration.
5622      ECD->setType(EnumType);
5623    else
5624      ECD->setType(NewTy);
5625  }
5626
5627  Enum->completeDefinition(Context, BestType);
5628}
5629
5630Sema::DeclPtrTy Sema::ActOnFileScopeAsmDecl(SourceLocation Loc,
5631                                            ExprArg expr) {
5632  StringLiteral *AsmString = cast<StringLiteral>(expr.takeAs<Expr>());
5633
5634  FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
5635                                                   Loc, AsmString);
5636  CurContext->addDecl(New);
5637  return DeclPtrTy::make(New);
5638}
5639
5640void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
5641                             SourceLocation PragmaLoc,
5642                             SourceLocation NameLoc) {
5643  Decl *PrevDecl = LookupSingleName(TUScope, Name, LookupOrdinaryName);
5644
5645  if (PrevDecl) {
5646    PrevDecl->addAttr(::new (Context) WeakAttr());
5647  } else {
5648    (void)WeakUndeclaredIdentifiers.insert(
5649      std::pair<IdentifierInfo*,WeakInfo>
5650        (Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
5651  }
5652}
5653
5654void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
5655                                IdentifierInfo* AliasName,
5656                                SourceLocation PragmaLoc,
5657                                SourceLocation NameLoc,
5658                                SourceLocation AliasNameLoc) {
5659  Decl *PrevDecl = LookupSingleName(TUScope, AliasName, LookupOrdinaryName);
5660  WeakInfo W = WeakInfo(Name, NameLoc);
5661
5662  if (PrevDecl) {
5663    if (!PrevDecl->hasAttr<AliasAttr>())
5664      if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
5665        DeclApplyPragmaWeak(TUScope, ND, W);
5666  } else {
5667    (void)WeakUndeclaredIdentifiers.insert(
5668      std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
5669  }
5670}
5671