Sema.cpp revision 429bb276991ff2dbc7c5b438828b9b7737cb15eb 
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/StmtCXX.h"
35#include "clang/Lex/Preprocessor.h"
36#include "clang/Basic/PartialDiagnostic.h"
37#include "clang/Basic/TargetInfo.h"
38using namespace clang;
39using namespace sema;
40
41FunctionScopeInfo::~FunctionScopeInfo() { }
42
43void FunctionScopeInfo::Clear() {
44  HasBranchProtectedScope = false;
45  HasBranchIntoScope = false;
46  HasIndirectGoto = false;
47
48  SwitchStack.clear();
49  Returns.clear();
50  ErrorTrap.reset();
51  PossiblyUnreachableDiags.clear();
52}
53
54BlockScopeInfo::~BlockScopeInfo() { }
55
56void Sema::ActOnTranslationUnitScope(Scope *S) {
57  TUScope = S;
58  PushDeclContext(S, Context.getTranslationUnitDecl());
59
60  VAListTagName = PP.getIdentifierInfo("__va_list_tag");
61
62  if (!Context.isInt128Installed() && // May be set by ASTReader.
63      PP.getTargetInfo().getPointerWidth(0) >= 64) {
64    TypeSourceInfo *TInfo;
65
66    // Install [u]int128_t for 64-bit targets.
67    TInfo = Context.getTrivialTypeSourceInfo(Context.Int128Ty);
68    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
69                                          SourceLocation(),
70                                          SourceLocation(),
71                                          &Context.Idents.get("__int128_t"),
72                                          TInfo), TUScope);
73
74    TInfo = Context.getTrivialTypeSourceInfo(Context.UnsignedInt128Ty);
75    PushOnScopeChains(TypedefDecl::Create(Context, CurContext,
76                                          SourceLocation(),
77                                          SourceLocation(),
78                                          &Context.Idents.get("__uint128_t"),
79                                          TInfo), TUScope);
80    Context.setInt128Installed();
81  }
82
83
84  if (!PP.getLangOptions().ObjC1) return;
85
86  // Built-in ObjC types may already be set by ASTReader (hence isNull checks).
87  if (Context.getObjCSelType().isNull()) {
88    // Create the built-in typedef for 'SEL'.
89    QualType SelT = Context.getPointerType(Context.ObjCBuiltinSelTy);
90    TypeSourceInfo *SelInfo = Context.getTrivialTypeSourceInfo(SelT);
91    TypedefDecl *SelTypedef
92      = TypedefDecl::Create(Context, CurContext,
93                            SourceLocation(), SourceLocation(),
94                            &Context.Idents.get("SEL"), SelInfo);
95    PushOnScopeChains(SelTypedef, TUScope);
96    Context.setObjCSelType(Context.getTypeDeclType(SelTypedef));
97    Context.ObjCSelRedefinitionType = Context.getObjCSelType();
98  }
99
100  // Synthesize "@class Protocol;
101  if (Context.getObjCProtoType().isNull()) {
102    ObjCInterfaceDecl *ProtocolDecl =
103      ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(),
104                                &Context.Idents.get("Protocol"),
105                                SourceLocation(), true);
106    Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl));
107    PushOnScopeChains(ProtocolDecl, TUScope, false);
108  }
109  // Create the built-in typedef for 'id'.
110  if (Context.getObjCIdType().isNull()) {
111    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinIdTy, 0, 0);
112    T = Context.getObjCObjectPointerType(T);
113    TypeSourceInfo *IdInfo = Context.getTrivialTypeSourceInfo(T);
114    TypedefDecl *IdTypedef
115      = TypedefDecl::Create(Context, CurContext,
116                            SourceLocation(), SourceLocation(),
117                            &Context.Idents.get("id"), IdInfo);
118    PushOnScopeChains(IdTypedef, TUScope);
119    Context.setObjCIdType(Context.getTypeDeclType(IdTypedef));
120    Context.ObjCIdRedefinitionType = Context.getObjCIdType();
121  }
122  // Create the built-in typedef for 'Class'.
123  if (Context.getObjCClassType().isNull()) {
124    QualType T = Context.getObjCObjectType(Context.ObjCBuiltinClassTy, 0, 0);
125    T = Context.getObjCObjectPointerType(T);
126    TypeSourceInfo *ClassInfo = Context.getTrivialTypeSourceInfo(T);
127    TypedefDecl *ClassTypedef
128      = TypedefDecl::Create(Context, CurContext,
129                            SourceLocation(), SourceLocation(),
130                            &Context.Idents.get("Class"), ClassInfo);
131    PushOnScopeChains(ClassTypedef, TUScope);
132    Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef));
133    Context.ObjCClassRedefinitionType = Context.getObjCClassType();
134  }
135}
136
137Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
138           bool CompleteTranslationUnit,
139           CodeCompleteConsumer *CodeCompleter)
140  : TheTargetAttributesSema(0), FPFeatures(pp.getLangOptions()),
141    LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer),
142    Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
143    ExternalSource(0), CodeCompleter(CodeCompleter), CurContext(0),
144    PackContext(0), VisContext(0),
145    IdResolver(pp.getLangOptions()), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
146    GlobalNewDeleteDeclared(false),
147    CompleteTranslationUnit(CompleteTranslationUnit),
148    NumSFINAEErrors(0), SuppressAccessChecking(false),
149    AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
150    NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
151    CurrentInstantiationScope(0), TyposCorrected(0),
152    AnalysisWarnings(*this)
153{
154  TUScope = 0;
155  if (getLangOptions().CPlusPlus)
156    FieldCollector.reset(new CXXFieldCollector());
157
158  // Tell diagnostics how to render things from the AST library.
159  PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
160                                       &Context);
161
162  ExprEvalContexts.push_back(
163                  ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0));
164
165  FunctionScopes.push_back(new FunctionScopeInfo(Diags));
166}
167
168void Sema::Initialize() {
169  // Tell the AST consumer about this Sema object.
170  Consumer.Initialize(Context);
171
172  // FIXME: Isn't this redundant with the initialization above?
173  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
174    SC->InitializeSema(*this);
175
176  // Tell the external Sema source about this Sema object.
177  if (ExternalSemaSource *ExternalSema
178      = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
179    ExternalSema->InitializeSema(*this);
180}
181
182Sema::~Sema() {
183  if (PackContext) FreePackedContext();
184  if (VisContext) FreeVisContext();
185  delete TheTargetAttributesSema;
186
187  // Kill all the active scopes.
188  for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
189    delete FunctionScopes[I];
190  if (FunctionScopes.size() == 1)
191    delete FunctionScopes[0];
192
193  // Tell the SemaConsumer to forget about us; we're going out of scope.
194  if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
195    SC->ForgetSema();
196
197  // Detach from the external Sema source.
198  if (ExternalSemaSource *ExternalSema
199        = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
200    ExternalSema->ForgetSema();
201}
202
203/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
204/// If there is already an implicit cast, merge into the existing one.
205/// The result is of the given category.
206ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
207                                   CastKind Kind, ExprValueKind VK,
208                                   const CXXCastPath *BasePath) {
209  QualType ExprTy = Context.getCanonicalType(E->getType());
210  QualType TypeTy = Context.getCanonicalType(Ty);
211
212  if (ExprTy == TypeTy)
213    return Owned(E);
214
215  // If this is a derived-to-base cast to a through a virtual base, we
216  // need a vtable.
217  if (Kind == CK_DerivedToBase &&
218      BasePathInvolvesVirtualBase(*BasePath)) {
219    QualType T = E->getType();
220    if (const PointerType *Pointer = T->getAs<PointerType>())
221      T = Pointer->getPointeeType();
222    if (const RecordType *RecordTy = T->getAs<RecordType>())
223      MarkVTableUsed(E->getLocStart(),
224                     cast<CXXRecordDecl>(RecordTy->getDecl()));
225  }
226
227  if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
228    if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
229      ImpCast->setType(Ty);
230      ImpCast->setValueKind(VK);
231      return Owned(E);
232    }
233  }
234
235  return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
236}
237
238/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
239/// to the conversion from scalar type ScalarTy to the Boolean type.
240CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
241  switch (ScalarTy->getScalarTypeKind()) {
242  case Type::STK_Bool: return CK_NoOp;
243  case Type::STK_Pointer: return CK_PointerToBoolean;
244  case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
245  case Type::STK_Integral: return CK_IntegralToBoolean;
246  case Type::STK_Floating: return CK_FloatingToBoolean;
247  case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
248  case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
249  }
250  return CK_Invalid;
251}
252
253ExprValueKind Sema::CastCategory(Expr *E) {
254  Expr::Classification Classification = E->Classify(Context);
255  return Classification.isRValue() ? VK_RValue :
256      (Classification.isLValue() ? VK_LValue : VK_XValue);
257}
258
259/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
260static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
261  if (D->isUsed())
262    return true;
263
264  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
265    // UnusedFileScopedDecls stores the first declaration.
266    // The declaration may have become definition so check again.
267    const FunctionDecl *DeclToCheck;
268    if (FD->hasBody(DeclToCheck))
269      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
270
271    // Later redecls may add new information resulting in not having to warn,
272    // so check again.
273    DeclToCheck = FD->getMostRecentDeclaration();
274    if (DeclToCheck != FD)
275      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
276  }
277
278  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
279    // UnusedFileScopedDecls stores the first declaration.
280    // The declaration may have become definition so check again.
281    const VarDecl *DeclToCheck = VD->getDefinition();
282    if (DeclToCheck)
283      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
284
285    // Later redecls may add new information resulting in not having to warn,
286    // so check again.
287    DeclToCheck = VD->getMostRecentDeclaration();
288    if (DeclToCheck != VD)
289      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
290  }
291
292  return false;
293}
294
295namespace {
296  struct UndefinedInternal {
297    NamedDecl *decl;
298    FullSourceLoc useLoc;
299
300    UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
301      : decl(decl), useLoc(useLoc) {}
302  };
303
304  bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) {
305    return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc);
306  }
307}
308
309/// checkUndefinedInternals - Check for undefined objects with internal linkage.
310static void checkUndefinedInternals(Sema &S) {
311  if (S.UndefinedInternals.empty()) return;
312
313  // Collect all the still-undefined entities with internal linkage.
314  llvm::SmallVector<UndefinedInternal, 16> undefined;
315  for (llvm::DenseMap<NamedDecl*,SourceLocation>::iterator
316         i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end();
317       i != e; ++i) {
318    NamedDecl *decl = i->first;
319
320    // Ignore attributes that have become invalid.
321    if (decl->isInvalidDecl()) continue;
322
323    // __attribute__((weakref)) is basically a definition.
324    if (decl->hasAttr<WeakRefAttr>()) continue;
325
326    if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
327      if (fn->isPure() || fn->hasBody())
328        continue;
329    } else {
330      if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly)
331        continue;
332    }
333
334    // We build a FullSourceLoc so that we can sort with array_pod_sort.
335    FullSourceLoc loc(i->second, S.Context.getSourceManager());
336    undefined.push_back(UndefinedInternal(decl, loc));
337  }
338
339  if (undefined.empty()) return;
340
341  // Sort (in order of use site) so that we're not (as) dependent on
342  // the iteration order through an llvm::DenseMap.
343  llvm::array_pod_sort(undefined.begin(), undefined.end());
344
345  for (llvm::SmallVectorImpl<UndefinedInternal>::iterator
346         i = undefined.begin(), e = undefined.end(); i != e; ++i) {
347    NamedDecl *decl = i->decl;
348    S.Diag(decl->getLocation(), diag::warn_undefined_internal)
349      << isa<VarDecl>(decl) << decl;
350    S.Diag(i->useLoc, diag::note_used_here);
351  }
352}
353
354/// ActOnEndOfTranslationUnit - This is called at the very end of the
355/// translation unit when EOF is reached and all but the top-level scope is
356/// popped.
357void Sema::ActOnEndOfTranslationUnit() {
358  // At PCH writing, implicit instantiations and VTable handling info are
359  // stored and performed when the PCH is included.
360  if (CompleteTranslationUnit) {
361    // If any dynamic classes have their key function defined within
362    // this translation unit, then those vtables are considered "used" and must
363    // be emitted.
364    for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) {
365      assert(!DynamicClasses[I]->isDependentType() &&
366             "Should not see dependent types here!");
367      if (const CXXMethodDecl *KeyFunction
368          = Context.getKeyFunction(DynamicClasses[I])) {
369        const FunctionDecl *Definition = 0;
370        if (KeyFunction->hasBody(Definition))
371          MarkVTableUsed(Definition->getLocation(), DynamicClasses[I], true);
372      }
373    }
374
375    // If DefinedUsedVTables ends up marking any virtual member functions it
376    // might lead to more pending template instantiations, which we then need
377    // to instantiate.
378    DefineUsedVTables();
379
380    // C++: Perform implicit template instantiations.
381    //
382    // FIXME: When we perform these implicit instantiations, we do not
383    // carefully keep track of the point of instantiation (C++ [temp.point]).
384    // This means that name lookup that occurs within the template
385    // instantiation will always happen at the end of the translation unit,
386    // so it will find some names that should not be found. Although this is
387    // common behavior for C++ compilers, it is technically wrong. In the
388    // future, we either need to be able to filter the results of name lookup
389    // or we need to perform template instantiations earlier.
390    PerformPendingInstantiations();
391  }
392
393  // Remove file scoped decls that turned out to be used.
394  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(),
395                                             UnusedFileScopedDecls.end(),
396                              std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
397                                           this)),
398                              UnusedFileScopedDecls.end());
399
400  if (!CompleteTranslationUnit) {
401    TUScope = 0;
402    return;
403  }
404
405  // Check for #pragma weak identifiers that were never declared
406  // FIXME: This will cause diagnostics to be emitted in a non-determinstic
407  // order!  Iterating over a densemap like this is bad.
408  for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
409       I = WeakUndeclaredIdentifiers.begin(),
410       E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
411    if (I->second.getUsed()) continue;
412
413    Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
414      << I->first;
415  }
416
417  // C99 6.9.2p2:
418  //   A declaration of an identifier for an object that has file
419  //   scope without an initializer, and without a storage-class
420  //   specifier or with the storage-class specifier static,
421  //   constitutes a tentative definition. If a translation unit
422  //   contains one or more tentative definitions for an identifier,
423  //   and the translation unit contains no external definition for
424  //   that identifier, then the behavior is exactly as if the
425  //   translation unit contains a file scope declaration of that
426  //   identifier, with the composite type as of the end of the
427  //   translation unit, with an initializer equal to 0.
428  llvm::SmallSet<VarDecl *, 32> Seen;
429  for (unsigned i = 0, e = TentativeDefinitions.size(); i != e; ++i) {
430    VarDecl *VD = TentativeDefinitions[i]->getActingDefinition();
431
432    // If the tentative definition was completed, getActingDefinition() returns
433    // null. If we've already seen this variable before, insert()'s second
434    // return value is false.
435    if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
436      continue;
437
438    if (const IncompleteArrayType *ArrayT
439        = Context.getAsIncompleteArrayType(VD->getType())) {
440      if (RequireCompleteType(VD->getLocation(),
441                              ArrayT->getElementType(),
442                              diag::err_tentative_def_incomplete_type_arr)) {
443        VD->setInvalidDecl();
444        continue;
445      }
446
447      // Set the length of the array to 1 (C99 6.9.2p5).
448      Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
449      llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
450      QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
451                                                One, ArrayType::Normal, 0);
452      VD->setType(T);
453    } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
454                                   diag::err_tentative_def_incomplete_type))
455      VD->setInvalidDecl();
456
457    // Notify the consumer that we've completed a tentative definition.
458    if (!VD->isInvalidDecl())
459      Consumer.CompleteTentativeDefinition(VD);
460
461  }
462
463  // If there were errors, disable 'unused' warnings since they will mostly be
464  // noise.
465  if (!Diags.hasErrorOccurred()) {
466    // Output warning for unused file scoped decls.
467    for (llvm::SmallVectorImpl<const DeclaratorDecl*>::iterator
468           I = UnusedFileScopedDecls.begin(),
469           E = UnusedFileScopedDecls.end(); I != E; ++I) {
470      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
471        const FunctionDecl *DiagD;
472        if (!FD->hasBody(DiagD))
473          DiagD = FD;
474        if (DiagD->isDeleted())
475          continue; // Deleted functions are supposed to be unused.
476        Diag(DiagD->getLocation(),
477             isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
478                                       : diag::warn_unused_function)
479              << DiagD->getDeclName();
480      } else {
481        const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
482        if (!DiagD)
483          DiagD = cast<VarDecl>(*I);
484        Diag(DiagD->getLocation(), diag::warn_unused_variable)
485              << DiagD->getDeclName();
486      }
487    }
488
489    checkUndefinedInternals(*this);
490  }
491
492  // Check we've noticed that we're no longer parsing the initializer for every
493  // variable. If we miss cases, then at best we have a performance issue and
494  // at worst a rejects-valid bug.
495  assert(ParsingInitForAutoVars.empty() &&
496         "Didn't unmark var as having its initializer parsed");
497
498  TUScope = 0;
499}
500
501
502//===----------------------------------------------------------------------===//
503// Helper functions.
504//===----------------------------------------------------------------------===//
505
506DeclContext *Sema::getFunctionLevelDeclContext() {
507  DeclContext *DC = CurContext;
508
509  while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC))
510    DC = DC->getParent();
511
512  return DC;
513}
514
515/// getCurFunctionDecl - If inside of a function body, this returns a pointer
516/// to the function decl for the function being parsed.  If we're currently
517/// in a 'block', this returns the containing context.
518FunctionDecl *Sema::getCurFunctionDecl() {
519  DeclContext *DC = getFunctionLevelDeclContext();
520  return dyn_cast<FunctionDecl>(DC);
521}
522
523ObjCMethodDecl *Sema::getCurMethodDecl() {
524  DeclContext *DC = getFunctionLevelDeclContext();
525  return dyn_cast<ObjCMethodDecl>(DC);
526}
527
528NamedDecl *Sema::getCurFunctionOrMethodDecl() {
529  DeclContext *DC = getFunctionLevelDeclContext();
530  if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
531    return cast<NamedDecl>(DC);
532  return 0;
533}
534
535Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() {
536  if (!isActive())
537    return;
538
539  if (llvm::Optional<TemplateDeductionInfo*> Info = SemaRef.isSFINAEContext()) {
540    switch (DiagnosticIDs::getDiagnosticSFINAEResponse(getDiagID())) {
541    case DiagnosticIDs::SFINAE_Report:
542      // Fall through; we'll report the diagnostic below.
543      break;
544
545    case DiagnosticIDs::SFINAE_AccessControl:
546      // Unless access checking is specifically called out as a SFINAE
547      // error, report this diagnostic.
548      if (!SemaRef.AccessCheckingSFINAE)
549        break;
550
551    case DiagnosticIDs::SFINAE_SubstitutionFailure:
552      // Count this failure so that we know that template argument deduction
553      // has failed.
554      ++SemaRef.NumSFINAEErrors;
555      SemaRef.Diags.setLastDiagnosticIgnored();
556      SemaRef.Diags.Clear();
557      Clear();
558      return;
559
560    case DiagnosticIDs::SFINAE_Suppress:
561      // Make a copy of this suppressed diagnostic and store it with the
562      // template-deduction information;
563      FlushCounts();
564      DiagnosticInfo DiagInfo(&SemaRef.Diags);
565
566      if (*Info)
567        (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
568                        PartialDiagnostic(DiagInfo,
569                                          SemaRef.Context.getDiagAllocator()));
570
571      // Suppress this diagnostic.
572      SemaRef.Diags.setLastDiagnosticIgnored();
573      SemaRef.Diags.Clear();
574      Clear();
575      return;
576    }
577  }
578
579  // Emit the diagnostic.
580  if (!this->Emit())
581    return;
582
583  // If this is not a note, and we're in a template instantiation
584  // that is different from the last template instantiation where
585  // we emitted an error, print a template instantiation
586  // backtrace.
587  if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
588      !SemaRef.ActiveTemplateInstantiations.empty() &&
589      SemaRef.ActiveTemplateInstantiations.back()
590        != SemaRef.LastTemplateInstantiationErrorContext) {
591    SemaRef.PrintInstantiationStack();
592    SemaRef.LastTemplateInstantiationErrorContext
593      = SemaRef.ActiveTemplateInstantiations.back();
594  }
595}
596
597Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) {
598  DiagnosticBuilder DB = Diags.Report(Loc, DiagID);
599  return SemaDiagnosticBuilder(DB, *this, DiagID);
600}
601
602Sema::SemaDiagnosticBuilder
603Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
604  SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
605  PD.Emit(Builder);
606
607  return Builder;
608}
609
610/// \brief Looks through the macro-instantiation chain for the given
611/// location, looking for a macro instantiation with the given name.
612/// If one is found, returns true and sets the location to that
613/// instantiation loc.
614bool Sema::findMacroSpelling(SourceLocation &locref, llvm::StringRef name) {
615  SourceLocation loc = locref;
616  if (!loc.isMacroID()) return false;
617
618  // There's no good way right now to look at the intermediate
619  // instantiations, so just jump to the instantiation location.
620  loc = getSourceManager().getInstantiationLoc(loc);
621
622  // If that's written with the name, stop here.
623  llvm::SmallVector<char, 16> buffer;
624  if (getPreprocessor().getSpelling(loc, buffer) == name) {
625    locref = loc;
626    return true;
627  }
628  return false;
629}
630
631/// \brief Determines the active Scope associated with the given declaration
632/// context.
633///
634/// This routine maps a declaration context to the active Scope object that
635/// represents that declaration context in the parser. It is typically used
636/// from "scope-less" code (e.g., template instantiation, lazy creation of
637/// declarations) that injects a name for name-lookup purposes and, therefore,
638/// must update the Scope.
639///
640/// \returns The scope corresponding to the given declaraion context, or NULL
641/// if no such scope is open.
642Scope *Sema::getScopeForContext(DeclContext *Ctx) {
643
644  if (!Ctx)
645    return 0;
646
647  Ctx = Ctx->getPrimaryContext();
648  for (Scope *S = getCurScope(); S; S = S->getParent()) {
649    // Ignore scopes that cannot have declarations. This is important for
650    // out-of-line definitions of static class members.
651    if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
652      if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
653        if (Ctx == Entity->getPrimaryContext())
654          return S;
655  }
656
657  return 0;
658}
659
660/// \brief Enter a new function scope
661void Sema::PushFunctionScope() {
662  if (FunctionScopes.size() == 1) {
663    // Use the "top" function scope rather than having to allocate
664    // memory for a new scope.
665    FunctionScopes.back()->Clear();
666    FunctionScopes.push_back(FunctionScopes.back());
667    return;
668  }
669
670  FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
671}
672
673void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
674  FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
675                                              BlockScope, Block));
676}
677
678void Sema::PopFunctionOrBlockScope(const AnalysisBasedWarnings::Policy *WP,
679                                   const Decl *D, const BlockExpr *blkExpr) {
680  FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
681  assert(!FunctionScopes.empty() && "mismatched push/pop!");
682
683  // Issue any analysis-based warnings.
684  if (WP && D)
685    AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
686  else {
687    for (llvm::SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
688         i = Scope->PossiblyUnreachableDiags.begin(),
689         e = Scope->PossiblyUnreachableDiags.end();
690         i != e; ++i) {
691      const sema::PossiblyUnreachableDiag &D = *i;
692      Diag(D.Loc, D.PD);
693    }
694  }
695
696  if (FunctionScopes.back() != Scope) {
697    delete Scope;
698  }
699}
700
701/// \brief Determine whether any errors occurred within this function/method/
702/// block.
703bool Sema::hasAnyErrorsInThisFunction() const {
704  return getCurFunction()->ErrorTrap.hasErrorOccurred();
705}
706
707BlockScopeInfo *Sema::getCurBlock() {
708  if (FunctionScopes.empty())
709    return 0;
710
711  return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
712}
713
714// Pin this vtable to this file.
715ExternalSemaSource::~ExternalSemaSource() {}
716
717std::pair<ObjCMethodList, ObjCMethodList>
718ExternalSemaSource::ReadMethodPool(Selector Sel) {
719  return std::pair<ObjCMethodList, ObjCMethodList>();
720}
721
722void PrettyDeclStackTraceEntry::print(llvm::raw_ostream &OS) const {
723  SourceLocation Loc = this->Loc;
724  if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
725  if (Loc.isValid()) {
726    Loc.print(OS, S.getSourceManager());
727    OS << ": ";
728  }
729  OS << Message;
730
731  if (TheDecl && isa<NamedDecl>(TheDecl)) {
732    std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
733    if (!Name.empty())
734      OS << " '" << Name << '\'';
735  }
736
737  OS << '\n';
738}
739