Home | History | Annotate | Download | only in Sema 
      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 "llvm/Support/CrashRecoveryContext.h"
     22 #include "clang/Sema/CXXFieldCollector.h"
     23 #include "clang/Sema/TemplateDeduction.h"
     24 #include "clang/Sema/ExternalSemaSource.h"
     25 #include "clang/Sema/ObjCMethodList.h"
     26 #include "clang/Sema/PrettyDeclStackTrace.h"
     27 #include "clang/Sema/Scope.h"
     28 #include "clang/Sema/ScopeInfo.h"
     29 #include "clang/Sema/SemaConsumer.h"
     30 #include "clang/AST/ASTContext.h"
     31 #include "clang/AST/ASTDiagnostic.h"
     32 #include "clang/AST/DeclCXX.h"
     33 #include "clang/AST/DeclFriend.h"
     34 #include "clang/AST/DeclObjC.h"
     35 #include "clang/AST/Expr.h"
     36 #include "clang/AST/ExprCXX.h"
     37 #include "clang/AST/StmtCXX.h"
     38 #include "clang/Lex/HeaderSearch.h"
     39 #include "clang/Lex/Preprocessor.h"
     40 #include "clang/Basic/FileManager.h"
     41 #include "clang/Basic/PartialDiagnostic.h"
     42 #include "clang/Basic/TargetInfo.h"
     43 using namespace clang;
     44 using namespace sema;
     45 
     46 FunctionScopeInfo::~FunctionScopeInfo() { }
     47 
     48 void FunctionScopeInfo::Clear() {
     49   HasBranchProtectedScope = false;
     50   HasBranchIntoScope = false;
     51   HasIndirectGoto = false;
     52 
     53   SwitchStack.clear();
     54   Returns.clear();
     55   ErrorTrap.reset();
     56   PossiblyUnreachableDiags.clear();
     57 }
     58 
     59 BlockScopeInfo::~BlockScopeInfo() { }
     60 LambdaScopeInfo::~LambdaScopeInfo() { }
     61 
     62 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
     63                                        const Preprocessor &PP) {
     64   PrintingPolicy Policy = Context.getPrintingPolicy();
     65   Policy.Bool = Context.getLangOpts().Bool;
     66   if (!Policy.Bool) {
     67     if (MacroInfo *BoolMacro = PP.getMacroInfo(&Context.Idents.get("bool"))) {
     68       Policy.Bool = BoolMacro->isObjectLike() &&
     69         BoolMacro->getNumTokens() == 1 &&
     70         BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
     71     }
     72   }
     73 
     74   return Policy;
     75 }
     76 
     77 void Sema::ActOnTranslationUnitScope(Scope *S) {
     78   TUScope = S;
     79   PushDeclContext(S, Context.getTranslationUnitDecl());
     80 
     81   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
     82 }
     83 
     84 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
     85            TranslationUnitKind TUKind,
     86            CodeCompleteConsumer *CodeCompleter)
     87   : TheTargetAttributesSema(0), FPFeatures(pp.getLangOpts()),
     88     LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
     89     Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
     90     CollectStats(false), ExternalSource(0), CodeCompleter(CodeCompleter),
     91     CurContext(0), OriginalLexicalContext(0),
     92     PackContext(0), MSStructPragmaOn(false), VisContext(0),
     93     ExprNeedsCleanups(false), LateTemplateParser(0), OpaqueParser(0),
     94     IdResolver(pp), StdInitializerList(0), CXXTypeInfoDecl(0), MSVCGuidDecl(0),
     95     NSNumberDecl(0),
     96     NSStringDecl(0), StringWithUTF8StringMethod(0),
     97     NSArrayDecl(0), ArrayWithObjectsMethod(0),
     98     NSDictionaryDecl(0), DictionaryWithObjectsMethod(0),
     99     GlobalNewDeleteDeclared(false),
    100     TUKind(TUKind),
    101     NumSFINAEErrors(0), InFunctionDeclarator(0),
    102     AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
    103     NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
    104     CurrentInstantiationScope(0), TyposCorrected(0),
    105     AnalysisWarnings(*this)
    106 {
    107   TUScope = 0;
    108 
    109   LoadedExternalKnownNamespaces = false;
    110   for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
    111     NSNumberLiteralMethods[I] = 0;
    112 
    113   if (getLangOpts().ObjC1)
    114     NSAPIObj.reset(new NSAPI(Context));
    115 
    116   if (getLangOpts().CPlusPlus)
    117     FieldCollector.reset(new CXXFieldCollector());
    118 
    119   // Tell diagnostics how to render things from the AST library.
    120   PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument,
    121                                        &Context);
    122 
    123   ExprEvalContexts.push_back(
    124         ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0,
    125                                           false, 0, false));
    126 
    127   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
    128 }
    129 
    130 void Sema::Initialize() {
    131   // Tell the AST consumer about this Sema object.
    132   Consumer.Initialize(Context);
    133 
    134   // FIXME: Isn't this redundant with the initialization above?
    135   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
    136     SC->InitializeSema(*this);
    137 
    138   // Tell the external Sema source about this Sema object.
    139   if (ExternalSemaSource *ExternalSema
    140       = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
    141     ExternalSema->InitializeSema(*this);
    142 
    143   // Initialize predefined 128-bit integer types, if needed.
    144   if (PP.getTargetInfo().getPointerWidth(0) >= 64) {
    145     // If either of the 128-bit integer types are unavailable to name lookup,
    146     // define them now.
    147     DeclarationName Int128 = &Context.Idents.get("__int128_t");
    148     if (IdResolver.begin(Int128) == IdResolver.end())
    149       PushOnScopeChains(Context.getInt128Decl(), TUScope);
    150 
    151     DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
    152     if (IdResolver.begin(UInt128) == IdResolver.end())
    153       PushOnScopeChains(Context.getUInt128Decl(), TUScope);
    154   }
    155 
    156 
    157   // Initialize predefined Objective-C types:
    158   if (PP.getLangOpts().ObjC1) {
    159     // If 'SEL' does not yet refer to any declarations, make it refer to the
    160     // predefined 'SEL'.
    161     DeclarationName SEL = &Context.Idents.get("SEL");
    162     if (IdResolver.begin(SEL) == IdResolver.end())
    163       PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
    164 
    165     // If 'id' does not yet refer to any declarations, make it refer to the
    166     // predefined 'id'.
    167     DeclarationName Id = &Context.Idents.get("id");
    168     if (IdResolver.begin(Id) == IdResolver.end())
    169       PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
    170 
    171     // Create the built-in typedef for 'Class'.
    172     DeclarationName Class = &Context.Idents.get("Class");
    173     if (IdResolver.begin(Class) == IdResolver.end())
    174       PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
    175 
    176     // Create the built-in forward declaratino for 'Protocol'.
    177     DeclarationName Protocol = &Context.Idents.get("Protocol");
    178     if (IdResolver.begin(Protocol) == IdResolver.end())
    179       PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
    180   }
    181 
    182   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
    183   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
    184     PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
    185 }
    186 
    187 Sema::~Sema() {
    188   if (PackContext) FreePackedContext();
    189   if (VisContext) FreeVisContext();
    190   delete TheTargetAttributesSema;
    191   MSStructPragmaOn = false;
    192   // Kill all the active scopes.
    193   for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
    194     delete FunctionScopes[I];
    195   if (FunctionScopes.size() == 1)
    196     delete FunctionScopes[0];
    197 
    198   // Tell the SemaConsumer to forget about us; we're going out of scope.
    199   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
    200     SC->ForgetSema();
    201 
    202   // Detach from the external Sema source.
    203   if (ExternalSemaSource *ExternalSema
    204         = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
    205     ExternalSema->ForgetSema();
    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                                          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 #ifndef NDEBUG
    254   if (VK == VK_RValue && !E->isRValue()) {
    255     switch (Kind) {
    256     default:
    257       assert(0 && "can't implicitly cast lvalue to rvalue with this cast kind");
    258     case CK_LValueToRValue:
    259     case CK_ArrayToPointerDecay:
    260     case CK_FunctionToPointerDecay:
    261     case CK_ToVoid:
    262       break;
    263     }
    264   }
    265   assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
    266 #endif
    267 
    268   QualType ExprTy = Context.getCanonicalType(E->getType());
    269   QualType TypeTy = Context.getCanonicalType(Ty);
    270 
    271   if (ExprTy == TypeTy)
    272     return Owned(E);
    273 
    274   if (getLangOpts().ObjCAutoRefCount)
    275     CheckObjCARCConversion(SourceRange(), Ty, E, CCK);
    276 
    277   // If this is a derived-to-base cast to a through a virtual base, we
    278   // need a vtable.
    279   if (Kind == CK_DerivedToBase &&
    280       BasePathInvolvesVirtualBase(*BasePath)) {
    281     QualType T = E->getType();
    282     if (const PointerType *Pointer = T->getAs<PointerType>())
    283       T = Pointer->getPointeeType();
    284     if (const RecordType *RecordTy = T->getAs<RecordType>())
    285       MarkVTableUsed(E->getLocStart(),
    286                      cast<CXXRecordDecl>(RecordTy->getDecl()));
    287   }
    288 
    289   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
    290     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
    291       ImpCast->setType(Ty);
    292       ImpCast->setValueKind(VK);
    293       return Owned(E);
    294     }
    295   }
    296 
    297   return Owned(ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK));
    298 }
    299 
    300 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
    301 /// to the conversion from scalar type ScalarTy to the Boolean type.
    302 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
    303   switch (ScalarTy->getScalarTypeKind()) {
    304   case Type::STK_Bool: return CK_NoOp;
    305   case Type::STK_CPointer: return CK_PointerToBoolean;
    306   case Type::STK_BlockPointer: return CK_PointerToBoolean;
    307   case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
    308   case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
    309   case Type::STK_Integral: return CK_IntegralToBoolean;
    310   case Type::STK_Floating: return CK_FloatingToBoolean;
    311   case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
    312   case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
    313   }
    314   return CK_Invalid;
    315 }
    316 
    317 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
    318 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
    319   if (D->isUsed())
    320     return true;
    321 
    322   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    323     // UnusedFileScopedDecls stores the first declaration.
    324     // The declaration may have become definition so check again.
    325     const FunctionDecl *DeclToCheck;
    326     if (FD->hasBody(DeclToCheck))
    327       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    328 
    329     // Later redecls may add new information resulting in not having to warn,
    330     // so check again.
    331     DeclToCheck = FD->getMostRecentDecl();
    332     if (DeclToCheck != FD)
    333       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    334   }
    335 
    336   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
    337     // UnusedFileScopedDecls stores the first declaration.
    338     // The declaration may have become definition so check again.
    339     const VarDecl *DeclToCheck = VD->getDefinition();
    340     if (DeclToCheck)
    341       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    342 
    343     // Later redecls may add new information resulting in not having to warn,
    344     // so check again.
    345     DeclToCheck = VD->getMostRecentDecl();
    346     if (DeclToCheck != VD)
    347       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    348   }
    349 
    350   return false;
    351 }
    352 
    353 namespace {
    354   struct UndefinedInternal {
    355     NamedDecl *decl;
    356     FullSourceLoc useLoc;
    357 
    358     UndefinedInternal(NamedDecl *decl, FullSourceLoc useLoc)
    359       : decl(decl), useLoc(useLoc) {}
    360   };
    361 
    362   bool operator<(const UndefinedInternal &l, const UndefinedInternal &r) {
    363     return l.useLoc.isBeforeInTranslationUnitThan(r.useLoc);
    364   }
    365 }
    366 
    367 /// checkUndefinedInternals - Check for undefined objects with internal linkage.
    368 static void checkUndefinedInternals(Sema &S) {
    369   if (S.UndefinedInternals.empty()) return;
    370 
    371   // Collect all the still-undefined entities with internal linkage.
    372   SmallVector<UndefinedInternal, 16> undefined;
    373   for (llvm::DenseMap<NamedDecl*,SourceLocation>::iterator
    374          i = S.UndefinedInternals.begin(), e = S.UndefinedInternals.end();
    375        i != e; ++i) {
    376     NamedDecl *decl = i->first;
    377 
    378     // Ignore attributes that have become invalid.
    379     if (decl->isInvalidDecl()) continue;
    380 
    381     // __attribute__((weakref)) is basically a definition.
    382     if (decl->hasAttr<WeakRefAttr>()) continue;
    383 
    384     if (FunctionDecl *fn = dyn_cast<FunctionDecl>(decl)) {
    385       if (fn->isPure() || fn->hasBody())
    386         continue;
    387     } else {
    388       if (cast<VarDecl>(decl)->hasDefinition() != VarDecl::DeclarationOnly)
    389         continue;
    390     }
    391 
    392     // We build a FullSourceLoc so that we can sort with array_pod_sort.
    393     FullSourceLoc loc(i->second, S.Context.getSourceManager());
    394     undefined.push_back(UndefinedInternal(decl, loc));
    395   }
    396 
    397   if (undefined.empty()) return;
    398 
    399   // Sort (in order of use site) so that we're not (as) dependent on
    400   // the iteration order through an llvm::DenseMap.
    401   llvm::array_pod_sort(undefined.begin(), undefined.end());
    402 
    403   for (SmallVectorImpl<UndefinedInternal>::iterator
    404          i = undefined.begin(), e = undefined.end(); i != e; ++i) {
    405     NamedDecl *decl = i->decl;
    406     S.Diag(decl->getLocation(), diag::warn_undefined_internal)
    407       << isa<VarDecl>(decl) << decl;
    408     S.Diag(i->useLoc, diag::note_used_here);
    409   }
    410 }
    411 
    412 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
    413   if (!ExternalSource)
    414     return;
    415 
    416   SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
    417   ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
    418   for (unsigned I = 0, N = WeakIDs.size(); I != N; ++I) {
    419     llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator Pos
    420       = WeakUndeclaredIdentifiers.find(WeakIDs[I].first);
    421     if (Pos != WeakUndeclaredIdentifiers.end())
    422       continue;
    423 
    424     WeakUndeclaredIdentifiers.insert(WeakIDs[I]);
    425   }
    426 }
    427 
    428 
    429 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
    430 
    431 /// \brief Returns true, if all methods and nested classes of the given
    432 /// CXXRecordDecl are defined in this translation unit.
    433 ///
    434 /// Should only be called from ActOnEndOfTranslationUnit so that all
    435 /// definitions are actually read.
    436 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
    437                                             RecordCompleteMap &MNCComplete) {
    438   RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
    439   if (Cache != MNCComplete.end())
    440     return Cache->second;
    441   if (!RD->isCompleteDefinition())
    442     return false;
    443   bool Complete = true;
    444   for (DeclContext::decl_iterator I = RD->decls_begin(),
    445                                   E = RD->decls_end();
    446        I != E && Complete; ++I) {
    447     if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
    448       Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
    449     else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
    450       Complete = F->getTemplatedDecl()->isDefined();
    451     else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
    452       if (R->isInjectedClassName())
    453         continue;
    454       if (R->hasDefinition())
    455         Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
    456                                                    MNCComplete);
    457       else
    458         Complete = false;
    459     }
    460   }
    461   MNCComplete[RD] = Complete;
    462   return Complete;
    463 }
    464 
    465 /// \brief Returns true, if the given CXXRecordDecl is fully defined in this
    466 /// translation unit, i.e. all methods are defined or pure virtual and all
    467 /// friends, friend functions and nested classes are fully defined in this
    468 /// translation unit.
    469 ///
    470 /// Should only be called from ActOnEndOfTranslationUnit so that all
    471 /// definitions are actually read.
    472 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
    473                                  RecordCompleteMap &RecordsComplete,
    474                                  RecordCompleteMap &MNCComplete) {
    475   RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
    476   if (Cache != RecordsComplete.end())
    477     return Cache->second;
    478   bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
    479   for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
    480                                       E = RD->friend_end();
    481        I != E && Complete; ++I) {
    482     // Check if friend classes and methods are complete.
    483     if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
    484       // Friend classes are available as the TypeSourceInfo of the FriendDecl.
    485       if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
    486         Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
    487       else
    488         Complete = false;
    489     } else {
    490       // Friend functions are available through the NamedDecl of FriendDecl.
    491       if (const FunctionDecl *FD =
    492           dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
    493         Complete = FD->isDefined();
    494       else
    495         // This is a template friend, give up.
    496         Complete = false;
    497     }
    498   }
    499   RecordsComplete[RD] = Complete;
    500   return Complete;
    501 }
    502 
    503 /// ActOnEndOfTranslationUnit - This is called at the very end of the
    504 /// translation unit when EOF is reached and all but the top-level scope is
    505 /// popped.
    506 void Sema::ActOnEndOfTranslationUnit() {
    507   assert(DelayedDiagnostics.getCurrentPool() == NULL
    508          && "reached end of translation unit with a pool attached?");
    509 
    510   // If code completion is enabled, don't perform any end-of-translation-unit
    511   // work.
    512   if (PP.isCodeCompletionEnabled())
    513     return;
    514 
    515   // Only complete translation units define vtables and perform implicit
    516   // instantiations.
    517   if (TUKind == TU_Complete) {
    518     DiagnoseUseOfUnimplementedSelectors();
    519 
    520     // If any dynamic classes have their key function defined within
    521     // this translation unit, then those vtables are considered "used" and must
    522     // be emitted.
    523     for (DynamicClassesType::iterator I = DynamicClasses.begin(ExternalSource),
    524                                       E = DynamicClasses.end();
    525          I != E; ++I) {
    526       assert(!(*I)->isDependentType() &&
    527              "Should not see dependent types here!");
    528       if (const CXXMethodDecl *KeyFunction = Context.getKeyFunction(*I)) {
    529         const FunctionDecl *Definition = 0;
    530         if (KeyFunction->hasBody(Definition))
    531           MarkVTableUsed(Definition->getLocation(), *I, true);
    532       }
    533     }
    534 
    535     // If DefinedUsedVTables ends up marking any virtual member functions it
    536     // might lead to more pending template instantiations, which we then need
    537     // to instantiate.
    538     DefineUsedVTables();
    539 
    540     // C++: Perform implicit template instantiations.
    541     //
    542     // FIXME: When we perform these implicit instantiations, we do not
    543     // carefully keep track of the point of instantiation (C++ [temp.point]).
    544     // This means that name lookup that occurs within the template
    545     // instantiation will always happen at the end of the translation unit,
    546     // so it will find some names that should not be found. Although this is
    547     // common behavior for C++ compilers, it is technically wrong. In the
    548     // future, we either need to be able to filter the results of name lookup
    549     // or we need to perform template instantiations earlier.
    550     PerformPendingInstantiations();
    551   }
    552 
    553   // Remove file scoped decls that turned out to be used.
    554   UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(0,
    555                                                                          true),
    556                                              UnusedFileScopedDecls.end(),
    557                               std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
    558                                            this)),
    559                               UnusedFileScopedDecls.end());
    560 
    561   if (TUKind == TU_Prefix) {
    562     // Translation unit prefixes don't need any of the checking below.
    563     TUScope = 0;
    564     return;
    565   }
    566 
    567   // Check for #pragma weak identifiers that were never declared
    568   // FIXME: This will cause diagnostics to be emitted in a non-determinstic
    569   // order!  Iterating over a densemap like this is bad.
    570   LoadExternalWeakUndeclaredIdentifiers();
    571   for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator
    572        I = WeakUndeclaredIdentifiers.begin(),
    573        E = WeakUndeclaredIdentifiers.end(); I != E; ++I) {
    574     if (I->second.getUsed()) continue;
    575 
    576     Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared)
    577       << I->first;
    578   }
    579 
    580   if (TUKind == TU_Module) {
    581     // If we are building a module, resolve all of the exported declarations
    582     // now.
    583     if (Module *CurrentModule = PP.getCurrentModule()) {
    584       ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
    585 
    586       llvm::SmallVector<Module *, 2> Stack;
    587       Stack.push_back(CurrentModule);
    588       while (!Stack.empty()) {
    589         Module *Mod = Stack.back();
    590         Stack.pop_back();
    591 
    592         // Resolve the exported declarations.
    593         // FIXME: Actually complain, once we figure out how to teach the
    594         // diagnostic client to deal with complains in the module map at this
    595         // point.
    596         ModMap.resolveExports(Mod, /*Complain=*/false);
    597 
    598         // Queue the submodules, so their exports will also be resolved.
    599         for (Module::submodule_iterator Sub = Mod->submodule_begin(),
    600                                      SubEnd = Mod->submodule_end();
    601              Sub != SubEnd; ++Sub) {
    602           Stack.push_back(*Sub);
    603         }
    604       }
    605     }
    606 
    607     // Modules don't need any of the checking below.
    608     TUScope = 0;
    609     return;
    610   }
    611 
    612   // C99 6.9.2p2:
    613   //   A declaration of an identifier for an object that has file
    614   //   scope without an initializer, and without a storage-class
    615   //   specifier or with the storage-class specifier static,
    616   //   constitutes a tentative definition. If a translation unit
    617   //   contains one or more tentative definitions for an identifier,
    618   //   and the translation unit contains no external definition for
    619   //   that identifier, then the behavior is exactly as if the
    620   //   translation unit contains a file scope declaration of that
    621   //   identifier, with the composite type as of the end of the
    622   //   translation unit, with an initializer equal to 0.
    623   llvm::SmallSet<VarDecl *, 32> Seen;
    624   for (TentativeDefinitionsType::iterator
    625             T = TentativeDefinitions.begin(ExternalSource),
    626          TEnd = TentativeDefinitions.end();
    627        T != TEnd; ++T)
    628   {
    629     VarDecl *VD = (*T)->getActingDefinition();
    630 
    631     // If the tentative definition was completed, getActingDefinition() returns
    632     // null. If we've already seen this variable before, insert()'s second
    633     // return value is false.
    634     if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD))
    635       continue;
    636 
    637     if (const IncompleteArrayType *ArrayT
    638         = Context.getAsIncompleteArrayType(VD->getType())) {
    639       if (RequireCompleteType(VD->getLocation(),
    640                               ArrayT->getElementType(),
    641                               diag::err_tentative_def_incomplete_type_arr)) {
    642         VD->setInvalidDecl();
    643         continue;
    644       }
    645 
    646       // Set the length of the array to 1 (C99 6.9.2p5).
    647       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
    648       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
    649       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
    650                                                 One, ArrayType::Normal, 0);
    651       VD->setType(T);
    652     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
    653                                    diag::err_tentative_def_incomplete_type))
    654       VD->setInvalidDecl();
    655 
    656     // Notify the consumer that we've completed a tentative definition.
    657     if (!VD->isInvalidDecl())
    658       Consumer.CompleteTentativeDefinition(VD);
    659 
    660   }
    661 
    662   if (LangOpts.CPlusPlus0x &&
    663       Diags.getDiagnosticLevel(diag::warn_delegating_ctor_cycle,
    664                                SourceLocation())
    665         != DiagnosticsEngine::Ignored)
    666     CheckDelegatingCtorCycles();
    667 
    668   // If there were errors, disable 'unused' warnings since they will mostly be
    669   // noise.
    670   if (!Diags.hasErrorOccurred()) {
    671     // Output warning for unused file scoped decls.
    672     for (UnusedFileScopedDeclsType::iterator
    673            I = UnusedFileScopedDecls.begin(ExternalSource),
    674            E = UnusedFileScopedDecls.end(); I != E; ++I) {
    675       if (ShouldRemoveFromUnused(this, *I))
    676         continue;
    677 
    678       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
    679         const FunctionDecl *DiagD;
    680         if (!FD->hasBody(DiagD))
    681           DiagD = FD;
    682         if (DiagD->isDeleted())
    683           continue; // Deleted functions are supposed to be unused.
    684         if (DiagD->isReferenced()) {
    685           if (isa<CXXMethodDecl>(DiagD))
    686             Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
    687                   << DiagD->getDeclName();
    688           else {
    689             if (FD->getStorageClassAsWritten() == SC_Static &&
    690                 !FD->isInlineSpecified() &&
    691                 !SourceMgr.isFromMainFile(
    692                    SourceMgr.getExpansionLoc(FD->getLocation())))
    693               Diag(DiagD->getLocation(), diag::warn_unneeded_static_internal_decl)
    694                 << DiagD->getDeclName();
    695             else
    696               Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
    697                    << /*function*/0 << DiagD->getDeclName();
    698           }
    699         } else {
    700           Diag(DiagD->getLocation(),
    701                isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
    702                                          : diag::warn_unused_function)
    703                 << DiagD->getDeclName();
    704         }
    705       } else {
    706         const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
    707         if (!DiagD)
    708           DiagD = cast<VarDecl>(*I);
    709         if (DiagD->isReferenced()) {
    710           Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
    711                 << /*variable*/1 << DiagD->getDeclName();
    712         } else {
    713           Diag(DiagD->getLocation(), diag::warn_unused_variable)
    714                 << DiagD->getDeclName();
    715         }
    716       }
    717     }
    718 
    719     checkUndefinedInternals(*this);
    720   }
    721 
    722   if (Diags.getDiagnosticLevel(diag::warn_unused_private_field,
    723                                SourceLocation())
    724         != DiagnosticsEngine::Ignored) {
    725     RecordCompleteMap RecordsComplete;
    726     RecordCompleteMap MNCComplete;
    727     for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
    728          E = UnusedPrivateFields.end(); I != E; ++I) {
    729       const NamedDecl *D = *I;
    730       const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
    731       if (RD && !RD->isUnion() &&
    732           IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
    733         Diag(D->getLocation(), diag::warn_unused_private_field)
    734               << D->getDeclName();
    735       }
    736     }
    737   }
    738 
    739   // Check we've noticed that we're no longer parsing the initializer for every
    740   // variable. If we miss cases, then at best we have a performance issue and
    741   // at worst a rejects-valid bug.
    742   assert(ParsingInitForAutoVars.empty() &&
    743          "Didn't unmark var as having its initializer parsed");
    744 
    745   TUScope = 0;
    746 }
    747 
    748 
    749 //===----------------------------------------------------------------------===//
    750 // Helper functions.
    751 //===----------------------------------------------------------------------===//
    752 
    753 DeclContext *Sema::getFunctionLevelDeclContext() {
    754   DeclContext *DC = CurContext;
    755 
    756   while (true) {
    757     if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) {
    758       DC = DC->getParent();
    759     } else if (isa<CXXMethodDecl>(DC) &&
    760                cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
    761                cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
    762       DC = DC->getParent()->getParent();
    763     }
    764     else break;
    765   }
    766 
    767   return DC;
    768 }
    769 
    770 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
    771 /// to the function decl for the function being parsed.  If we're currently
    772 /// in a 'block', this returns the containing context.
    773 FunctionDecl *Sema::getCurFunctionDecl() {
    774   DeclContext *DC = getFunctionLevelDeclContext();
    775   return dyn_cast<FunctionDecl>(DC);
    776 }
    777 
    778 ObjCMethodDecl *Sema::getCurMethodDecl() {
    779   DeclContext *DC = getFunctionLevelDeclContext();
    780   return dyn_cast<ObjCMethodDecl>(DC);
    781 }
    782 
    783 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
    784   DeclContext *DC = getFunctionLevelDeclContext();
    785   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
    786     return cast<NamedDecl>(DC);
    787   return 0;
    788 }
    789 
    790 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
    791   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
    792   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
    793   // been made more painfully obvious by the refactor that introduced this
    794   // function, but it is possible that the incoming argument can be
    795   // eliminnated. If it truly cannot be (for example, there is some reentrancy
    796   // issue I am not seeing yet), then there should at least be a clarifying
    797   // comment somewhere.
    798   if (llvm::Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
    799     switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
    800               Diags.getCurrentDiagID())) {
    801     case DiagnosticIDs::SFINAE_Report:
    802       // We'll report the diagnostic below.
    803       break;
    804 
    805     case DiagnosticIDs::SFINAE_SubstitutionFailure:
    806       // Count this failure so that we know that template argument deduction
    807       // has failed.
    808       ++NumSFINAEErrors;
    809 
    810       // Make a copy of this suppressed diagnostic and store it with the
    811       // template-deduction information.
    812       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
    813         Diagnostic DiagInfo(&Diags);
    814         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
    815                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
    816       }
    817 
    818       Diags.setLastDiagnosticIgnored();
    819       Diags.Clear();
    820       return;
    821 
    822     case DiagnosticIDs::SFINAE_AccessControl: {
    823       // Per C++ Core Issue 1170, access control is part of SFINAE.
    824       // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
    825       // make access control a part of SFINAE for the purposes of checking
    826       // type traits.
    827       if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus0x)
    828         break;
    829 
    830       SourceLocation Loc = Diags.getCurrentDiagLoc();
    831 
    832       // Suppress this diagnostic.
    833       ++NumSFINAEErrors;
    834 
    835       // Make a copy of this suppressed diagnostic and store it with the
    836       // template-deduction information.
    837       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
    838         Diagnostic DiagInfo(&Diags);
    839         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
    840                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
    841       }
    842 
    843       Diags.setLastDiagnosticIgnored();
    844       Diags.Clear();
    845 
    846       // Now the diagnostic state is clear, produce a C++98 compatibility
    847       // warning.
    848       Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
    849 
    850       // The last diagnostic which Sema produced was ignored. Suppress any
    851       // notes attached to it.
    852       Diags.setLastDiagnosticIgnored();
    853       return;
    854     }
    855 
    856     case DiagnosticIDs::SFINAE_Suppress:
    857       // Make a copy of this suppressed diagnostic and store it with the
    858       // template-deduction information;
    859       if (*Info) {
    860         Diagnostic DiagInfo(&Diags);
    861         (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
    862                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
    863       }
    864 
    865       // Suppress this diagnostic.
    866       Diags.setLastDiagnosticIgnored();
    867       Diags.Clear();
    868       return;
    869     }
    870   }
    871 
    872   // Set up the context's printing policy based on our current state.
    873   Context.setPrintingPolicy(getPrintingPolicy());
    874 
    875   // Emit the diagnostic.
    876   if (!Diags.EmitCurrentDiagnostic())
    877     return;
    878 
    879   // If this is not a note, and we're in a template instantiation
    880   // that is different from the last template instantiation where
    881   // we emitted an error, print a template instantiation
    882   // backtrace.
    883   if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
    884       !ActiveTemplateInstantiations.empty() &&
    885       ActiveTemplateInstantiations.back()
    886         != LastTemplateInstantiationErrorContext) {
    887     PrintInstantiationStack();
    888     LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
    889   }
    890 }
    891 
    892 Sema::SemaDiagnosticBuilder
    893 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
    894   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
    895   PD.Emit(Builder);
    896 
    897   return Builder;
    898 }
    899 
    900 /// \brief Looks through the macro-expansion chain for the given
    901 /// location, looking for a macro expansion with the given name.
    902 /// If one is found, returns true and sets the location to that
    903 /// expansion loc.
    904 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
    905   SourceLocation loc = locref;
    906   if (!loc.isMacroID()) return false;
    907 
    908   // There's no good way right now to look at the intermediate
    909   // expansions, so just jump to the expansion location.
    910   loc = getSourceManager().getExpansionLoc(loc);
    911 
    912   // If that's written with the name, stop here.
    913   SmallVector<char, 16> buffer;
    914   if (getPreprocessor().getSpelling(loc, buffer) == name) {
    915     locref = loc;
    916     return true;
    917   }
    918   return false;
    919 }
    920 
    921 /// \brief Determines the active Scope associated with the given declaration
    922 /// context.
    923 ///
    924 /// This routine maps a declaration context to the active Scope object that
    925 /// represents that declaration context in the parser. It is typically used
    926 /// from "scope-less" code (e.g., template instantiation, lazy creation of
    927 /// declarations) that injects a name for name-lookup purposes and, therefore,
    928 /// must update the Scope.
    929 ///
    930 /// \returns The scope corresponding to the given declaraion context, or NULL
    931 /// if no such scope is open.
    932 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
    933 
    934   if (!Ctx)
    935     return 0;
    936 
    937   Ctx = Ctx->getPrimaryContext();
    938   for (Scope *S = getCurScope(); S; S = S->getParent()) {
    939     // Ignore scopes that cannot have declarations. This is important for
    940     // out-of-line definitions of static class members.
    941     if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
    942       if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity()))
    943         if (Ctx == Entity->getPrimaryContext())
    944           return S;
    945   }
    946 
    947   return 0;
    948 }
    949 
    950 /// \brief Enter a new function scope
    951 void Sema::PushFunctionScope() {
    952   if (FunctionScopes.size() == 1) {
    953     // Use the "top" function scope rather than having to allocate
    954     // memory for a new scope.
    955     FunctionScopes.back()->Clear();
    956     FunctionScopes.push_back(FunctionScopes.back());
    957     return;
    958   }
    959 
    960   FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
    961 }
    962 
    963 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
    964   FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
    965                                               BlockScope, Block));
    966 }
    967 
    968 void Sema::PushLambdaScope(CXXRecordDecl *Lambda,
    969                            CXXMethodDecl *CallOperator) {
    970   FunctionScopes.push_back(new LambdaScopeInfo(getDiagnostics(), Lambda,
    971                                                CallOperator));
    972 }
    973 
    974 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
    975                                 const Decl *D, const BlockExpr *blkExpr) {
    976   FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
    977   assert(!FunctionScopes.empty() && "mismatched push/pop!");
    978 
    979   // Issue any analysis-based warnings.
    980   if (WP && D)
    981     AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
    982   else {
    983     for (SmallVectorImpl<sema::PossiblyUnreachableDiag>::iterator
    984          i = Scope->PossiblyUnreachableDiags.begin(),
    985          e = Scope->PossiblyUnreachableDiags.end();
    986          i != e; ++i) {
    987       const sema::PossiblyUnreachableDiag &D = *i;
    988       Diag(D.Loc, D.PD);
    989     }
    990   }
    991 
    992   if (FunctionScopes.back() != Scope) {
    993     delete Scope;
    994   }
    995 }
    996 
    997 void Sema::PushCompoundScope() {
    998   getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
    999 }
   1000 
   1001 void Sema::PopCompoundScope() {
   1002   FunctionScopeInfo *CurFunction = getCurFunction();
   1003   assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
   1004 
   1005   CurFunction->CompoundScopes.pop_back();
   1006 }
   1007 
   1008 /// \brief Determine whether any errors occurred within this function/method/
   1009 /// block.
   1010 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
   1011   return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
   1012 }
   1013 
   1014 BlockScopeInfo *Sema::getCurBlock() {
   1015   if (FunctionScopes.empty())
   1016     return 0;
   1017 
   1018   return dyn_cast<BlockScopeInfo>(FunctionScopes.back());
   1019 }
   1020 
   1021 LambdaScopeInfo *Sema::getCurLambda() {
   1022   if (FunctionScopes.empty())
   1023     return 0;
   1024 
   1025   return dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
   1026 }
   1027 
   1028 void Sema::ActOnComment(SourceRange Comment) {
   1029   RawComment RC(SourceMgr, Comment);
   1030   if (RC.isAlmostTrailingComment()) {
   1031     SourceRange MagicMarkerRange(Comment.getBegin(),
   1032                                  Comment.getBegin().getLocWithOffset(3));
   1033     StringRef MagicMarkerText;
   1034     switch (RC.getKind()) {
   1035     case RawComment::RCK_OrdinaryBCPL:
   1036       MagicMarkerText = "///<";
   1037       break;
   1038     case RawComment::RCK_OrdinaryC:
   1039       MagicMarkerText = "/**<";
   1040       break;
   1041     default:
   1042       llvm_unreachable("if this is an almost Doxygen comment, "
   1043                        "it should be ordinary");
   1044     }
   1045     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
   1046       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
   1047   }
   1048   Context.addComment(RC);
   1049 }
   1050 
   1051 // Pin this vtable to this file.
   1052 ExternalSemaSource::~ExternalSemaSource() {}
   1053 
   1054 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
   1055 
   1056 void ExternalSemaSource::ReadKnownNamespaces(
   1057                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
   1058 }
   1059 
   1060 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
   1061   SourceLocation Loc = this->Loc;
   1062   if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
   1063   if (Loc.isValid()) {
   1064     Loc.print(OS, S.getSourceManager());
   1065     OS << ": ";
   1066   }
   1067   OS << Message;
   1068 
   1069   if (TheDecl && isa<NamedDecl>(TheDecl)) {
   1070     std::string Name = cast<NamedDecl>(TheDecl)->getNameAsString();
   1071     if (!Name.empty())
   1072       OS << " '" << Name << '\'';
   1073   }
   1074 
   1075   OS << '\n';
   1076 }
   1077 
   1078 /// \brief Figure out if an expression could be turned into a call.
   1079 ///
   1080 /// Use this when trying to recover from an error where the programmer may have
   1081 /// written just the name of a function instead of actually calling it.
   1082 ///
   1083 /// \param E - The expression to examine.
   1084 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
   1085 ///  with no arguments, this parameter is set to the type returned by such a
   1086 ///  call; otherwise, it is set to an empty QualType.
   1087 /// \param OverloadSet - If the expression is an overloaded function
   1088 ///  name, this parameter is populated with the decls of the various overloads.
   1089 bool Sema::isExprCallable(const Expr &E, QualType &ZeroArgCallReturnTy,
   1090                           UnresolvedSetImpl &OverloadSet) {
   1091   ZeroArgCallReturnTy = QualType();
   1092   OverloadSet.clear();
   1093 
   1094   if (E.getType() == Context.OverloadTy) {
   1095     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
   1096     const OverloadExpr *Overloads = FR.Expression;
   1097 
   1098     for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
   1099          DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
   1100       OverloadSet.addDecl(*it);
   1101 
   1102       // Check whether the function is a non-template which takes no
   1103       // arguments.
   1104       if (const FunctionDecl *OverloadDecl
   1105             = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
   1106         if (OverloadDecl->getMinRequiredArguments() == 0)
   1107           ZeroArgCallReturnTy = OverloadDecl->getResultType();
   1108       }
   1109     }
   1110 
   1111     // Ignore overloads that are pointer-to-member constants.
   1112     if (FR.HasFormOfMemberPointer)
   1113       return false;
   1114 
   1115     return true;
   1116   }
   1117 
   1118   if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
   1119     if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
   1120       if (Fun->getMinRequiredArguments() == 0)
   1121         ZeroArgCallReturnTy = Fun->getResultType();
   1122       return true;
   1123     }
   1124   }
   1125 
   1126   // We don't have an expression that's convenient to get a FunctionDecl from,
   1127   // but we can at least check if the type is "function of 0 arguments".
   1128   QualType ExprTy = E.getType();
   1129   const FunctionType *FunTy = NULL;
   1130   QualType PointeeTy = ExprTy->getPointeeType();
   1131   if (!PointeeTy.isNull())
   1132     FunTy = PointeeTy->getAs<FunctionType>();
   1133   if (!FunTy)
   1134     FunTy = ExprTy->getAs<FunctionType>();
   1135   if (!FunTy && ExprTy == Context.BoundMemberTy) {
   1136     // Look for the bound-member type.  If it's still overloaded, give up,
   1137     // although we probably should have fallen into the OverloadExpr case above
   1138     // if we actually have an overloaded bound member.
   1139     QualType BoundMemberTy = Expr::findBoundMemberType(&E);
   1140     if (!BoundMemberTy.isNull())
   1141       FunTy = BoundMemberTy->castAs<FunctionType>();
   1142   }
   1143 
   1144   if (const FunctionProtoType *FPT =
   1145       dyn_cast_or_null<FunctionProtoType>(FunTy)) {
   1146     if (FPT->getNumArgs() == 0)
   1147       ZeroArgCallReturnTy = FunTy->getResultType();
   1148     return true;
   1149   }
   1150   return false;
   1151 }
   1152 
   1153 /// \brief Give notes for a set of overloads.
   1154 ///
   1155 /// A companion to isExprCallable. In cases when the name that the programmer
   1156 /// wrote was an overloaded function, we may be able to make some guesses about
   1157 /// plausible overloads based on their return types; such guesses can be handed
   1158 /// off to this method to be emitted as notes.
   1159 ///
   1160 /// \param Overloads - The overloads to note.
   1161 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
   1162 ///  -fshow-overloads=best, this is the location to attach to the note about too
   1163 ///  many candidates. Typically this will be the location of the original
   1164 ///  ill-formed expression.
   1165 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
   1166                           const SourceLocation FinalNoteLoc) {
   1167   int ShownOverloads = 0;
   1168   int SuppressedOverloads = 0;
   1169   for (UnresolvedSetImpl::iterator It = Overloads.begin(),
   1170        DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
   1171     // FIXME: Magic number for max shown overloads stolen from
   1172     // OverloadCandidateSet::NoteCandidates.
   1173     if (ShownOverloads >= 4 &&
   1174         S.Diags.getShowOverloads() == DiagnosticsEngine::Ovl_Best) {
   1175       ++SuppressedOverloads;
   1176       continue;
   1177     }
   1178 
   1179     NamedDecl *Fn = (*It)->getUnderlyingDecl();
   1180     S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
   1181     ++ShownOverloads;
   1182   }
   1183 
   1184   if (SuppressedOverloads)
   1185     S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
   1186       << SuppressedOverloads;
   1187 }
   1188 
   1189 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
   1190                                    const UnresolvedSetImpl &Overloads,
   1191                                    bool (*IsPlausibleResult)(QualType)) {
   1192   if (!IsPlausibleResult)
   1193     return noteOverloads(S, Overloads, Loc);
   1194 
   1195   UnresolvedSet<2> PlausibleOverloads;
   1196   for (OverloadExpr::decls_iterator It = Overloads.begin(),
   1197          DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
   1198     const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
   1199     QualType OverloadResultTy = OverloadDecl->getResultType();
   1200     if (IsPlausibleResult(OverloadResultTy))
   1201       PlausibleOverloads.addDecl(It.getDecl());
   1202   }
   1203   noteOverloads(S, PlausibleOverloads, Loc);
   1204 }
   1205 
   1206 /// Determine whether the given expression can be called by just
   1207 /// putting parentheses after it.  Notably, expressions with unary
   1208 /// operators can't be because the unary operator will start parsing
   1209 /// outside the call.
   1210 static bool IsCallableWithAppend(Expr *E) {
   1211   E = E->IgnoreImplicit();
   1212   return (!isa<CStyleCastExpr>(E) &&
   1213           !isa<UnaryOperator>(E) &&
   1214           !isa<BinaryOperator>(E) &&
   1215           !isa<CXXOperatorCallExpr>(E));
   1216 }
   1217 
   1218 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
   1219                                 bool ForceComplain,
   1220                                 bool (*IsPlausibleResult)(QualType)) {
   1221   SourceLocation Loc = E.get()->getExprLoc();
   1222   SourceRange Range = E.get()->getSourceRange();
   1223 
   1224   QualType ZeroArgCallTy;
   1225   UnresolvedSet<4> Overloads;
   1226   if (isExprCallable(*E.get(), ZeroArgCallTy, Overloads) &&
   1227       !ZeroArgCallTy.isNull() &&
   1228       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
   1229     // At this point, we know E is potentially callable with 0
   1230     // arguments and that it returns something of a reasonable type,
   1231     // so we can emit a fixit and carry on pretending that E was
   1232     // actually a CallExpr.
   1233     SourceLocation ParenInsertionLoc =
   1234       PP.getLocForEndOfToken(Range.getEnd());
   1235     Diag(Loc, PD)
   1236       << /*zero-arg*/ 1 << Range
   1237       << (IsCallableWithAppend(E.get())
   1238           ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
   1239           : FixItHint());
   1240     notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
   1241 
   1242     // FIXME: Try this before emitting the fixit, and suppress diagnostics
   1243     // while doing so.
   1244     E = ActOnCallExpr(0, E.take(), ParenInsertionLoc,
   1245                       MultiExprArg(), ParenInsertionLoc.getLocWithOffset(1));
   1246     return true;
   1247   }
   1248 
   1249   if (!ForceComplain) return false;
   1250 
   1251   Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
   1252   notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
   1253   E = ExprError();
   1254   return true;
   1255 }
   1256