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