Sema.cpp revision a2ee20aa9660851080135219cac5b31fbac08b78 
1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
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 the actions class which performs semantic analysis and
11// builds an AST out of a parse stream.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Sema/SemaInternal.h"
16#include "clang/Sema/DelayedDiagnostic.h"
17#include "TargetAttributesSema.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/ADT/SmallSet.h"
20#include "llvm/ADT/APFloat.h"
21#include "clang/Sema/CXXFieldCollector.h"
22#include "clang/Sema/TemplateDeduction.h"
23#include "clang/Sema/ExternalSemaSource.h"
24#include "clang/Sema/ObjCMethodList.h"
25#include "clang/Sema/PrettyDeclStackTrace.h"
26#include "clang/Sema/Scope.h"
27#include "clang/Sema/ScopeInfo.h"
28#include "clang/Sema/SemaConsumer.h"
29#include "clang/AST/ASTContext.h"
30#include "clang/AST/ASTDiagnostic.h"
31#include "clang/AST/DeclCXX.h"
32#include "clang/AST/DeclObjC.h"
33#include "clang/AST/Expr.h"
34#include "clang/AST/ExprCXX.h"
35#include "clang/AST/StmtCXX.h"
36#include "clang/Lex/Preprocessor.h"
37#include "clang/Basic/PartialDiagnostic.h"
38#include "clang/Basic/TargetInfo.h"
39using namespace clang;
40using namespace sema;
41
42FunctionScopeInfo::~FunctionScopeInfo() { }
43
44void FunctionScopeInfo::Clear() {
45  HasBranchProtectedScope = false;
46  HasBranchIntoScope = false;
47  HasIndirectGoto = false;
48
49  SwitchStack.clear();
50  Returns.clear();
51  ErrorTrap.reset();
52  PossiblyUnreachableDiags.clear();
53}
54
55BlockScopeInfo::~BlockScopeInfo() { }
56
57void Sema::ActOnTranslationUnitScope(Scope *S) {
58  TUScope = S;
59  PushDeclContext(S, Context.getTranslationUnitDecl());
60
61  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
62
63  if (!Context.isInt128Installed() && // May be set by ASTReader.
64      PP.getTargetInfo().getPointerWidth(0) >= 64) {
65    TypeSourceInfo *TInfo;
66
67    // Install [u]int128_t for 64-bit targets.
68    TInfo = Context.getTrivialTypeSourceInfo(Context.Int128Ty);
69    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
70                                          SourceLocation(),
71                                          SourceLocation(),
72                                          &Context.Idents.get("__int128_t"),
73                                          TInfo), TUScope);
74
75    TInfo = Context.getTrivialTypeSourceInfo(Context.UnsignedInt128Ty);
76    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
77                                          SourceLocation(),
78                                          SourceLocation(),
79                                          &Context.Idents.get("__uint128_t"),
80                                          TInfo), TUScope);
81    Context.setInt128Installed();
82  }
83
84
85  if (!PP.getLangOptions().ObjC1) return;
86
87  // Built-in ObjC types may already be set by ASTReader (hence isNull checks).
88  if (Context.getObjCSelType().isNull()) {
89    // Create the built-in typedef for 'SEL'.
90    QualType SelT = Context.getPointerType(Context.ObjCBuiltinSelTy);
91    TypeSourceInfo *SelInfo = Context.getTrivialTypeSourceInfo(SelT);
92    TypedefDecl *SelTypedef
93      = TypedefDecl::Create(Context, CurContext,
94                            SourceLocation(), SourceLocation(),
95                            &Context.Idents.get("SEL"), SelInfo);
96    PushOnScopeChains(SelTypedef, TUScope);
97    Context.setObjCSelType(Context.getTypeDeclType(SelTypedef));
98    Context.ObjCSelRedefinitionType = Context.getObjCSelType();
99  }
100
101  // Synthesize "@class Protocol;
102  if (Context.getObjCProtoType().isNull()) {
103    ObjCInterfaceDecl *ProtocolDecl =
104      ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(),
105                                &Context.Idents.get("Protocol"),
106                                SourceLocation(), true);
107    Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl));
108    PushOnScopeChains(ProtocolDecl, TUScope, false);
109  }
110  // Create the built-in typedef for 'id'.
111  if (Context.getObjCIdType().isNull()) {
112    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinIdTy, 0, 0);
113    T = Context.getObjCObjectPointerType(T);
114    TypeSourceInfo *IdInfo = Context.getTrivialTypeSourceInfo(T);
115    TypedefDecl *IdTypedef
116      = TypedefDecl::Create(Context, CurContext,
117                            SourceLocation(), SourceLocation(),
118                            &Context.Idents.get("id"), IdInfo);
119    PushOnScopeChains(IdTypedef, TUScope);
120    Context.setObjCIdType(Context.getTypeDeclType(IdTypedef));
121    Context.ObjCIdRedefinitionType = Context.getObjCIdType();
122  }
123  // Create the built-in typedef for 'Class'.
124  if (Context.getObjCClassType().isNull()) {
125    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinClassTy, 0, 0);
126    T = Context.getObjCObjectPointerType(T);
127    TypeSourceInfo *ClassInfo = Context.getTrivialTypeSourceInfo(T);
128    TypedefDecl *ClassTypedef
129      = TypedefDecl::Create(Context, CurContext,
130                            SourceLocation(), SourceLocation(),
131                            &Context.Idents.get("Class"), ClassInfo);
132    PushOnScopeChains(ClassTypedef, TUScope);
133    Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef));
134    Context.ObjCClassRedefinitionType = Context.getObjCClassType();
135  }
136}
137
138Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
139           bool CompleteTranslationUnit,
140           CodeCompleteConsumer *CodeCompleter)
141  : TheTargetAttributesSema(0), FPFeatures(pp.getLangOptions()),
142    LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer),
143    Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
144    CollectStats(false), ExternalSource(0), CodeCompleter(CodeCompleter),
145    CurContext(0), PackContext(0), MSStructPragmaOn(false), VisContext(0),
146    ExprNeedsCleanups(0), LateTemplateParser(0), OpaqueParser(0),
147    IdResolver(pp.getLangOptions()), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
148    GlobalNewDeleteDeclared(false),
149    CompleteTranslationUnit(CompleteTranslationUnit),
150    NumSFINAEErrors(0), SuppressAccessChecking(false),
151    AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
152    NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
153    CurrentInstantiationScope(0), TyposCorrected(0),
154    AnalysisWarnings(*this)
155{
156  TUScope = 0;
157  LoadedExternalKnownNamespaces = false;
158
159  if (getLangOptions().CPlusPlus)
160    FieldCollector.reset(new CXXFieldCollector());
161
162  // Tell diagnostics how to render things from the AST library.
163  PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
164                                       &Context);
165
166  ExprEvalContexts.push_back(
167        ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0, false));
168
169  FunctionScopes.push_back(new FunctionScopeInfo(Diags));
170}
171
172void Sema::Initialize() {
173  // Tell the AST consumer about this Sema object.
174  Consumer.Initialize(Context);
175
176  // FIXME: Isn't this redundant with the initialization above?
177  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
178    SC->InitializeSema(*this);
179
180  // Tell the external Sema source about this Sema object.
181  if (ExternalSemaSource *ExternalSema
182      = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
183    ExternalSema->InitializeSema(*this);
184}
185
186Sema::~Sema() {
187  if (PackContext) FreePackedContext();
188  if (VisContext) FreeVisContext();
189  delete TheTargetAttributesSema;
190  MSStructPragmaOn = false;
191  // Kill all the active scopes.
192  for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
193    delete FunctionScopes[I];
194  if (FunctionScopes.size() == 1)
195    delete FunctionScopes[0];
196
197  // Tell the SemaConsumer to forget about us; we're going out of scope.
198  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
199    SC->ForgetSema();
200
201  // Detach from the external Sema source.
202  if (ExternalSemaSource *ExternalSema
203        = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
204    ExternalSema->ForgetSema();
205}
206
207
208/// makeUnavailableInSystemHeader - There is an error in the current
209/// context.  If we're still in a system header, and we can plausibly
210/// make the relevant declaration unavailable instead of erroring, do
211/// so and return true.
212bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
213                                         StringRef msg) {
214  // If we're not in a function, it's an error.
215  FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
216  if (!fn) return false;
217
218  // If we're in template instantiation, it's an error.
219  if (!ActiveTemplateInstantiations.empty())
220    return false;
221
222  // If that function's not in a system header, it's an error.
223  if (!Context.getSourceManager().isInSystemHeader(loc))
224    return false;
225
226  // If the function is already unavailable, it's not an error.
227  if (fn->hasAttr<UnavailableAttr>()) return true;
228
229  fn->addAttr(new (Context) UnavailableAttr(loc, Context, msg));
230  return true;
231}
232
233ASTMutationListener *Sema::getASTMutationListener() const {
234  return getASTConsumer().GetASTMutationListener();
235}
236
237/// \brief Print out statistics about the semantic analysis.
238void Sema::PrintStats() const {
239  llvm::errs() << "\n*** Semantic Analysis Stats:\n";
240  llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
241
242  BumpAlloc.PrintStats();
243  AnalysisWarnings.PrintStats();
244}
245
246/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
247/// If there is already an implicit cast, merge into the existing one.
248/// The result is of the given category.
249ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
250                                   CastKind Kind, ExprValueKind VK,
251                                   const CXXCastPath *BasePath,
252                                   CheckedConversionKind CCK) {
253  QualType ExprTy = Context.getCanonicalType(E->getType());
254  QualType TypeTy = Context.getCanonicalType(Ty);
255
256  if (ExprTy == TypeTy)
257    return Owned(E);
258
259  if (getLangOptions().ObjCAutoRefCount)
260    CheckObjCARCConversion(SourceRange(), Ty, E, CCK);
261
262  // If this is a derived-to-base cast to a through a virtual base, we
263  // need a vtable.
264  if (Kind == CK_DerivedToBase &&
265      BasePathInvolvesVirtualBase(*BasePath)) {
266    QualType T = E->getType();
267    if (const PointerType *Pointer = T->getAs<PointerType>())
268      T = Pointer->getPointeeType();
269    if (const RecordType *RecordTy = T->getAs<RecordType>())
270      MarkVTableUsed(E->getLocStart(),
271                     cast<CXXRecordDecl>(RecordTy->getDecl()));
272  }
273
274  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
275    if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
276      ImpCast->setType(Ty);
277      ImpCast->setValueKind(VK);
278      return Owned(E);
279    }
280  }
281
282  return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
283}
284
285/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
286/// to the conversion from scalar type ScalarTy to the Boolean type.
287CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
288  switch (ScalarTy->getScalarTypeKind()) {
289  case Type::STK_Bool: return CK_NoOp;
290  case Type::STK_Pointer: return CK_PointerToBoolean;
291  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
292  case Type::STK_Integral: return CK_IntegralToBoolean;
293  case Type::STK_Floating: return CK_FloatingToBoolean;
294  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
295  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
296  }
297  return CK_Invalid;
298}
299
300ExprValueKind Sema::CastCategory(Expr *E) {
301  Expr::Classification Classification = E->Classify(Context);
302  return Classification.isRValue() ? VK_RValue :
303      (Classification.isLValue() ? VK_LValue : VK_XValue);
304}
305
306/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
307static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
308  if (D->isUsed())
309    return true;
310
311  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
312    // UnusedFileScopedDecls stores the first declaration.
313    // The declaration may have become definition so check again.
314    const FunctionDecl *DeclToCheck;
315    if (FD->hasBody(DeclToCheck))
316      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
317
318    // Later redecls may add new information resulting in not having to warn,
319    // so check again.
320    DeclToCheck = FD->getMostRecentDeclaration();
321    if (DeclToCheck != FD)
322      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
323  }
324
325  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
326    // UnusedFileScopedDecls stores the first declaration.
327    // The declaration may have become definition so check again.
328    const VarDecl *DeclToCheck = VD->getDefinition();
329    if (DeclToCheck)
330      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
331
332    // Later redecls may add new information resulting in not having to warn,
333    // so check again.
334    DeclToCheck = VD->getMostRecentDeclaration();
335    if (DeclToCheck != VD)
336      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
337  }
338
339  return false;
340}
341
342namespace {
343  struct UndefinedInternal {
344    NamedDecl *decl;
345    FullSourceLoc useLoc;
346
347    UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
348      : decl(decl), useLoc(useLoc) {}
349  };
350
351  bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) {
352    return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc);
353  }
354}
355
356/// checkUndefinedInternals - Check for undefined objects with internal linkage.
357static void checkUndefinedInternals(Sema &S) {
358  if (S.UndefinedInternals.empty()) return;
359
360  // Collect all the still-undefined entities with internal linkage.
361  SmallVector<UndefinedInternal, 16> undefined;
362  for (llvm::DenseMap<NamedDecl*,SourceLocation>::iterator
363         i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end();
364       i != e; ++i) {
365    NamedDecl *decl = i->first;
366
367    // Ignore attributes that have become invalid.
368    if (decl->isInvalidDecl()) continue;
369
370    // __attribute__((weakref)) is basically a definition.
371    if (decl->hasAttr<WeakRefAttr>()) continue;
372
373    if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
374      if (fn->isPure() || fn->hasBody())
375        continue;
376    } else {
377      if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly)
378        continue;
379    }
380
381    // We build a FullSourceLoc so that we can sort with array_pod_sort.
382    FullSourceLoc loc(i->second, S.Context.getSourceManager());
383    undefined.push_back(UndefinedInternal(decl, loc));
384  }
385
386  if (undefined.empty()) return;
387
388  // Sort (in order of use site) so that we're not (as) dependent on
389  // the iteration order through an llvm::DenseMap.
390  llvm::array_pod_sort(undefined.begin(), undefined.end());
391
392  for (SmallVectorImpl<UndefinedInternal>::iterator
393         i = undefined.begin(), e = undefined.end(); i != e; ++i) {
394    NamedDecl *decl = i->decl;
395    S.Diag(decl->getLocation(), diag::warn_undefined_internal)
396      << isa<VarDecl>(decl) << decl;
397    S.Diag(i->useLoc, diag::note_used_here);
398  }
399}
400
401/// ActOnEndOfTranslationUnit - This is called at the very end of the
402/// translation unit when EOF is reached and all but the top-level scope is
403/// popped.
404void Sema::ActOnEndOfTranslationUnit() {
405  // At PCH writing, implicit instantiations and VTable handling info are
406  // stored and performed when the PCH is included.
407  if (CompleteTranslationUnit) {
408    // If any dynamic classes have their key function defined within
409    // this translation unit, then those vtables are considered "used" and must
410    // be emitted.
411    for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
412      assert(!DynamicClasses[I]->isDependentType() &&
413             "Should not see dependent types here!");
414      if (const CXXMethodDecl *KeyFunction
415          = Context.getKeyFunction(DynamicClasses[I])) {
416        const FunctionDecl *Definition = 0;
417        if (KeyFunction->hasBody(Definition))
418          MarkVTableUsed(Definition->getLocation(), DynamicClasses[I], true);
419      }
420    }
421
422    // If DefinedUsedVTables ends up marking any virtual member functions it
423    // might lead to more pending template instantiations, which we then need
424    // to instantiate.
425    DefineUsedVTables();
426
427    // C++: Perform implicit template instantiations.
428    //
429    // FIXME: When we perform these implicit instantiations, we do not
430    // carefully keep track of the point of instantiation (C++ [temp.point]).
431    // This means that name lookup that occurs within the template
432    // instantiation will always happen at the end of the translation unit,
433    // so it will find some names that should not be found. Although this is
434    // common behavior for C++ compilers, it is technically wrong. In the
435    // future, we either need to be able to filter the results of name lookup
436    // or we need to perform template instantiations earlier.
437    PerformPendingInstantiations();
438  }
439
440  // Remove file scoped decls that turned out to be used.
441  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(0,
442                                                                         true),
443                                             UnusedFileScopedDecls.end(),
444                              std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
445                                           this)),
446                              UnusedFileScopedDecls.end());
447
448  if (!CompleteTranslationUnit) {
449    TUScope = 0;
450    return;
451  }
452
453  // Check for #pragma weak identifiers that were never declared
454  // FIXME: This will cause diagnostics to be emitted in a non-determinstic
455  // order!  Iterating over a densemap like this is bad.
456  for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
457       I = WeakUndeclaredIdentifiers.begin(),
458       E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
459    if (I->second.getUsed()) continue;
460
461    Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
462      << I->first;
463  }
464
465  // C99 6.9.2p2:
466  //   A declaration of an identifier for an object that has file
467  //   scope without an initializer, and without a storage-class
468  //   specifier or with the storage-class specifier static,
469  //   constitutes a tentative definition. If a translation unit
470  //   contains one or more tentative definitions for an identifier,
471  //   and the translation unit contains no external definition for
472  //   that identifier, then the behavior is exactly as if the
473  //   translation unit contains a file scope declaration of that
474  //   identifier, with the composite type as of the end of the
475  //   translation unit, with an initializer equal to 0.
476  llvm::SmallSet<VarDecl *, 32> Seen;
477  for (TentativeDefinitionsType::iterator
478            T = TentativeDefinitions.begin(ExternalSource),
479         TEnd = TentativeDefinitions.end();
480       T != TEnd; ++T)
481  {
482    VarDecl *VD = (*T)->getActingDefinition();
483
484    // If the tentative definition was completed, getActingDefinition() returns
485    // null. If we've already seen this variable before, insert()'s second
486    // return value is false.
487    if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
488      continue;
489
490    if (const IncompleteArrayType *ArrayT
491        = Context.getAsIncompleteArrayType(VD->getType())) {
492      if (RequireCompleteType(VD->getLocation(),
493                              ArrayT->getElementType(),
494                              diag::err_tentative_def_incomplete_type_arr)) {
495        VD->setInvalidDecl();
496        continue;
497      }
498
499      // Set the length of the array to 1 (C99 6.9.2p5).
500      Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
501      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
502      QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
503                                                One, ArrayType::Normal, 0);
504      VD->setType(T);
505    } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
506                                   diag::err_tentative_def_incomplete_type))
507      VD->setInvalidDecl();
508
509    // Notify the consumer that we've completed a tentative definition.
510    if (!VD->isInvalidDecl())
511      Consumer.CompleteTentativeDefinition(VD);
512
513  }
514
515  if (LangOpts.CPlusPlus0x &&
516      Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
517                               SourceLocation())
518        != Diagnostic::Ignored)
519    CheckDelegatingCtorCycles();
520
521  // If there were errors, disable 'unused' warnings since they will mostly be
522  // noise.
523  if (!Diags.hasErrorOccurred()) {
524    // Output warning for unused file scoped decls.
525    for (UnusedFileScopedDeclsType::iterator
526           I = UnusedFileScopedDecls.begin(ExternalSource),
527           E = UnusedFileScopedDecls.end(); I != E; ++I) {
528      if (ShouldRemoveFromUnused(this, *I))
529        continue;
530
531      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
532        const FunctionDecl *DiagD;
533        if (!FD->hasBody(DiagD))
534          DiagD = FD;
535        if (DiagD->isDeleted())
536          continue; // Deleted functions are supposed to be unused.
537        if (DiagD->isReferenced()) {
538          if (isa<CXXMethodDecl>(DiagD))
539            Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
540                  << DiagD->getDeclName();
541          else
542            Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
543                  << /*function*/0 << DiagD->getDeclName();
544        } else {
545          Diag(DiagD->getLocation(),
546               isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
547                                         : diag::warn_unused_function)
548                << DiagD->getDeclName();
549        }
550      } else {
551        const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
552        if (!DiagD)
553          DiagD = cast<VarDecl>(*I);
554        if (DiagD->isReferenced()) {
555          Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
556                << /*variable*/1 << DiagD->getDeclName();
557        } else {
558          Diag(DiagD->getLocation(), diag::warn_unused_variable)
559                << DiagD->getDeclName();
560        }
561      }
562    }
563
564    checkUndefinedInternals(*this);
565  }
566
567  // Check we've noticed that we're no longer parsing the initializer for every
568  // variable. If we miss cases, then at best we have a performance issue and
569  // at worst a rejects-valid bug.
570  assert(ParsingInitForAutoVars.empty() &&
571         "Didn't unmark var as having its initializer parsed");
572
573  TUScope = 0;
574}
575
576
577//===----------------------------------------------------------------------===//
578// Helper functions.
579//===----------------------------------------------------------------------===//
580
581DeclContext *Sema::getFunctionLevelDeclContext() {
582  DeclContext *DC = CurContext;
583
584  while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC))
585    DC = DC->getParent();
586
587  return DC;
588}
589
590/// getCurFunctionDecl - If inside of a function body, this returns a pointer
591/// to the function decl for the function being parsed.  If we're currently
592/// in a 'block', this returns the containing context.
593FunctionDecl *Sema::getCurFunctionDecl() {
594  DeclContext *DC = getFunctionLevelDeclContext();
595  return dyn_cast<FunctionDecl>(DC);
596}
597
598ObjCMethodDecl *Sema::getCurMethodDecl() {
599  DeclContext *DC = getFunctionLevelDeclContext();
600  return dyn_cast<ObjCMethodDecl>(DC);
601}
602
603NamedDecl *Sema::getCurFunctionOrMethodDecl() {
604  DeclContext *DC = getFunctionLevelDeclContext();
605  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
606    return cast<NamedDecl>(DC);
607  return 0;
608}
609
610Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
611  if (!isActive())
612    return;
613
614  if (llvm::Optional<TemplateDeductionInfo*> Info = SemaRef.isSFINAEContext()) {
615    switch (DiagnosticIDs::getDiagnosticSFINAEResponse(getDiagID())) {
616    case DiagnosticIDs::SFINAE_Report:
617      // Fall through; we'll report the diagnostic below.
618      break;
619
620    case DiagnosticIDs::SFINAE_AccessControl:
621      // Per C++ Core Issue 1170, access control is part of SFINAE.
622      // Additionally, the AccessCheckingSFINAE flag can be used to temporary
623      // make access control a part of SFINAE for the purposes of checking
624      // type traits.
625      if (!SemaRef.AccessCheckingSFINAE &&
626          !SemaRef.getLangOptions().CPlusPlus0x)
627        break;
628
629    case DiagnosticIDs::SFINAE_SubstitutionFailure:
630      // Count this failure so that we know that template argument deduction
631      // has failed.
632      ++SemaRef.NumSFINAEErrors;
633      SemaRef.Diags.setLastDiagnosticIgnored();
634      SemaRef.Diags.Clear();
635      Clear();
636      return;
637
638    case DiagnosticIDs::SFINAE_Suppress:
639      // Make a copy of this suppressed diagnostic and store it with the
640      // template-deduction information;
641      FlushCounts();
642      DiagnosticInfo DiagInfo(&SemaRef.Diags);
643
644      if (*Info)
645        (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
646                        PartialDiagnostic(DiagInfo,
647                                          SemaRef.Context.getDiagAllocator()));
648
649      // Suppress this diagnostic.
650      SemaRef.Diags.setLastDiagnosticIgnored();
651      SemaRef.Diags.Clear();
652      Clear();
653      return;
654    }
655  }
656
657  // Emit the diagnostic.
658  if (!this->Emit())
659    return;
660
661  // If this is not a note, and we're in a template instantiation
662  // that is different from the last template instantiation where
663  // we emitted an error, print a template instantiation
664  // backtrace.
665  if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
666      !SemaRef.ActiveTemplateInstantiations.empty() &&
667      SemaRef.ActiveTemplateInstantiations.back()
668        != SemaRef.LastTemplateInstantiationErrorContext) {
669    SemaRef.PrintInstantiationStack();
670    SemaRef.LastTemplateInstantiationErrorContext
671      = SemaRef.ActiveTemplateInstantiations.back();
672  }
673}
674
675Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
676  DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
677  return SemaDiagnosticBuilder(DB, *this, DiagID);
678}
679
680Sema::SemaDiagnosticBuilder
681Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
682  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
683  PD.Emit(Builder);
684
685  return Builder;
686}
687
688/// \brief Looks through the macro-expansion chain for the given
689/// location, looking for a macro expansion with the given name.
690/// If one is found, returns true and sets the location to that
691/// expansion loc.
692bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
693  SourceLocation loc = locref;
694  if (!loc.isMacroID()) return false;
695
696  // There's no good way right now to look at the intermediate
697  // expansions, so just jump to the expansion location.
698  loc = getSourceManager().getExpansionLoc(loc);
699
700  // If that's written with the name, stop here.
701  SmallVector<char, 16> buffer;
702  if (getPreprocessor().getSpelling(loc, buffer) == name) {
703    locref = loc;
704    return true;
705  }
706  return false;
707}
708
709/// \brief Determines the active Scope associated with the given declaration
710/// context.
711///
712/// This routine maps a declaration context to the active Scope object that
713/// represents that declaration context in the parser. It is typically used
714/// from "scope-less" code (e.g., template instantiation, lazy creation of
715/// declarations) that injects a name for name-lookup purposes and, therefore,
716/// must update the Scope.
717///
718/// \returns The scope corresponding to the given declaraion context, or NULL
719/// if no such scope is open.
720Scope *Sema::getScopeForContext(DeclContext *Ctx) {
721
722  if (!Ctx)
723    return 0;
724
725  Ctx = Ctx->getPrimaryContext();
726  for (Scope *S = getCurScope(); S; S = S->getParent()) {
727    // Ignore scopes that cannot have declarations. This is important for
728    // out-of-line definitions of static class members.
729    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
730      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
731        if (Ctx == Entity->getPrimaryContext())
732          return S;
733  }
734
735  return 0;
736}
737
738/// \brief Enter a new function scope
739void Sema::PushFunctionScope() {
740  if (FunctionScopes.size() == 1) {
741    // Use the "top" function scope rather than having to allocate
742    // memory for a new scope.
743    FunctionScopes.back()->Clear();
744    FunctionScopes.push_back(FunctionScopes.back());
745    return;
746  }
747
748  FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
749}
750
751void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
752  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
753                                              BlockScope, Block));
754}
755
756void Sema::PopFunctionOrBlockScope(const AnalysisBasedWarnings::Policy *WP,
757                                   const Decl *D, const BlockExpr *blkExpr) {
758  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
759  assert(!FunctionScopes.empty() && "mismatched push/pop!");
760
761  // Issue any analysis-based warnings.
762  if (WP && D)
763    AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
764  else {
765    for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
766         i = Scope->PossiblyUnreachableDiags.begin(),
767         e = Scope->PossiblyUnreachableDiags.end();
768         i != e; ++i) {
769      const sema::PossiblyUnreachableDiag &D = *i;
770      Diag(D.Loc, D.PD);
771    }
772  }
773
774  if (FunctionScopes.back() != Scope) {
775    delete Scope;
776  }
777}
778
779/// \brief Determine whether any errors occurred within this function/method/
780/// block.
781bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
782  return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
783}
784
785BlockScopeInfo *Sema::getCurBlock() {
786  if (FunctionScopes.empty())
787    return 0;
788
789  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
790}
791
792// Pin this vtable to this file.
793ExternalSemaSource::~ExternalSemaSource() {}
794
795std::pair<ObjCMethodList, ObjCMethodList>
796ExternalSemaSource::ReadMethodPool(Selector Sel) {
797  return std::pair<ObjCMethodList, ObjCMethodList>();
798}
799
800void ExternalSemaSource::ReadKnownNamespaces(
801                           SmallVectorImpl<NamespaceDecl *> &Namespaces) {
802}
803
804void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
805  SourceLocation Loc = this->Loc;
806  if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
807  if (Loc.isValid()) {
808    Loc.print(OS, S.getSourceManager());
809    OS << ": ";
810  }
811  OS << Message;
812
813  if (TheDecl && isa<NamedDecl>(TheDecl)) {
814    std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
815    if (!Name.empty())
816      OS << " '" << Name << '\'';
817  }
818
819  OS << '\n';
820}
821
822/// \brief Figure out if an expression could be turned into a call.
823///
824/// Use this when trying to recover from an error where the programmer may have
825/// written just the name of a function instead of actually calling it.
826///
827/// \param E - The expression to examine.
828/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
829///  with no arguments, this parameter is set to the type returned by such a
830///  call; otherwise, it is set to an empty QualType.
831/// \param NonTemplateOverloads - If the expression is an overloaded function
832///  name, this parameter is populated with the decls of the various overloads.
833bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
834                          UnresolvedSetImpl &NonTemplateOverloads) {
835  ZeroArgCallReturnTy = QualType();
836  NonTemplateOverloads.clear();
837  if (const OverloadExpr *Overloads = dyn_cast<OverloadExpr>(&E)) {
838    for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
839         DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
840      // Our overload set may include TemplateDecls, which we'll ignore for our
841      // present purpose.
842      if (const FunctionDecl *OverloadDecl = dyn_cast<FunctionDecl>(*it)) {
843        NonTemplateOverloads.addDecl(*it);
844        if (OverloadDecl->getMinRequiredArguments() == 0)
845          ZeroArgCallReturnTy = OverloadDecl->getResultType();
846      }
847    }
848    return true;
849  }
850
851  if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(&E)) {
852    if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
853      if (Fun->getMinRequiredArguments() == 0)
854        ZeroArgCallReturnTy = Fun->getResultType();
855      return true;
856    }
857  }
858
859  // We don't have an expression that's convenient to get a FunctionDecl from,
860  // but we can at least check if the type is "function of 0 arguments".
861  QualType ExprTy = E.getType();
862  const FunctionType *FunTy = NULL;
863  QualType PointeeTy = ExprTy->getPointeeType();
864  if (!PointeeTy.isNull())
865    FunTy = PointeeTy->getAs<FunctionType>();
866  if (!FunTy)
867    FunTy = ExprTy->getAs<FunctionType>();
868  if (!FunTy && ExprTy == Context.BoundMemberTy) {
869    // Look for the bound-member type.  If it's still overloaded, give up,
870    // although we probably should have fallen into the OverloadExpr case above
871    // if we actually have an overloaded bound member.
872    QualType BoundMemberTy = Expr::findBoundMemberType(&E);
873    if (!BoundMemberTy.isNull())
874      FunTy = BoundMemberTy->castAs<FunctionType>();
875  }
876
877  if (const FunctionProtoType *FPT =
878      dyn_cast_or_null<FunctionProtoType>(FunTy)) {
879    if (FPT->getNumArgs() == 0)
880      ZeroArgCallReturnTy = FunTy->getResultType();
881    return true;
882  }
883  return false;
884}
885
886/// \brief Give notes for a set of overloads.
887///
888/// A companion to isExprCallable. In cases when the name that the programmer
889/// wrote was an overloaded function, we may be able to make some guesses about
890/// plausible overloads based on their return types; such guesses can be handed
891/// off to this method to be emitted as notes.
892///
893/// \param Overloads - The overloads to note.
894/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
895///  -fshow-overloads=best, this is the location to attach to the note about too
896///  many candidates. Typically this will be the location of the original
897///  ill-formed expression.
898void Sema::NoteOverloads(const UnresolvedSetImpl &Overloads,
899                         const SourceLocation FinalNoteLoc) {
900  int ShownOverloads = 0;
901  int SuppressedOverloads = 0;
902  for (UnresolvedSetImpl::iterator It = Overloads.begin(),
903       DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
904    // FIXME: Magic number for max shown overloads stolen from
905    // OverloadCandidateSet::NoteCandidates.
906    if (ShownOverloads >= 4 &&
907        Diags.getShowOverloads() == Diagnostic::Ovl_Best) {
908      ++SuppressedOverloads;
909      continue;
910    }
911    Diag(cast<FunctionDecl>(*It)->getSourceRange().getBegin(),
912         diag::note_member_ref_possible_intended_overload);
913    ++ShownOverloads;
914  }
915  if (SuppressedOverloads)
916    Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
917        << SuppressedOverloads;
918}
919