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