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