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