contrib/llvm/tools/clang/lib/Sema/Sema.cpp

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