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/AST/ASTContext.h"
     17 #include "clang/AST/ASTDiagnostic.h"
     18 #include "clang/AST/DeclCXX.h"
     19 #include "clang/AST/DeclFriend.h"
     20 #include "clang/AST/DeclObjC.h"
     21 #include "clang/AST/Expr.h"
     22 #include "clang/AST/ExprCXX.h"
     23 #include "clang/AST/StmtCXX.h"
     24 #include "clang/Basic/DiagnosticOptions.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 using namespace clang;
     44 using namespace sema;
     45 
     46 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
     47   return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
     48 }
     49 
     50 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
     51 
     52 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
     53                                        const Preprocessor &PP) {
     54   PrintingPolicy Policy = Context.getPrintingPolicy();
     55   // Our printing policy is copied over the ASTContext printing policy whenever
     56   // a diagnostic is emitted, so recompute it.
     57   Policy.Bool = Context.getLangOpts().Bool;
     58   if (!Policy.Bool) {
     59     if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
     60       Policy.Bool = BoolMacro->isObjectLike() &&
     61                     BoolMacro->getNumTokens() == 1 &&
     62                     BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
     63     }
     64   }
     65 
     66   return Policy;
     67 }
     68 
     69 void Sema::ActOnTranslationUnitScope(Scope *S) {
     70   TUScope = S;
     71   PushDeclContext(S, Context.getTranslationUnitDecl());
     72 }
     73 
     74 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
     75            TranslationUnitKind TUKind,
     76            CodeCompleteConsumer *CodeCompleter)
     77   : ExternalSource(nullptr),
     78     isMultiplexExternalSource(false), FPFeatures(pp.getLangOpts()),
     79     LangOpts(pp.getLangOpts()), PP(pp), Context(ctxt), Consumer(consumer),
     80     Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()),
     81     CollectStats(false), CodeCompleter(CodeCompleter),
     82     CurContext(nullptr), OriginalLexicalContext(nullptr),
     83     MSStructPragmaOn(false),
     84     MSPointerToMemberRepresentationMethod(
     85         LangOpts.getMSPointerToMemberRepresentationMethod()),
     86     VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)),
     87     PackStack(0), DataSegStack(nullptr), BSSSegStack(nullptr),
     88     ConstSegStack(nullptr), CodeSegStack(nullptr), CurInitSeg(nullptr),
     89     VisContext(nullptr),
     90     IsBuildingRecoveryCallExpr(false),
     91     Cleanup{}, LateTemplateParser(nullptr),
     92     LateTemplateParserCleanup(nullptr),
     93     OpaqueParser(nullptr), IdResolver(pp), StdInitializerList(nullptr),
     94     CXXTypeInfoDecl(nullptr), MSVCGuidDecl(nullptr),
     95     NSNumberDecl(nullptr), NSValueDecl(nullptr),
     96     NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
     97     ValueWithBytesObjCTypeMethod(nullptr),
     98     NSArrayDecl(nullptr), ArrayWithObjectsMethod(nullptr),
     99     NSDictionaryDecl(nullptr), DictionaryWithObjectsMethod(nullptr),
    100     MSAsmLabelNameCounter(0),
    101     GlobalNewDeleteDeclared(false),
    102     TUKind(TUKind),
    103     NumSFINAEErrors(0),
    104     CachedFakeTopLevelModule(nullptr),
    105     AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
    106     NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
    107     CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
    108     TyposCorrected(0), AnalysisWarnings(*this), ThreadSafetyDeclCache(nullptr),
    109     VarDataSharingAttributesStack(nullptr), CurScope(nullptr),
    110     Ident_super(nullptr), Ident___float128(nullptr)
    111 {
    112   TUScope = nullptr;
    113 
    114   LoadedExternalKnownNamespaces = false;
    115   for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
    116     NSNumberLiteralMethods[I] = nullptr;
    117 
    118   if (getLangOpts().ObjC1)
    119     NSAPIObj.reset(new NSAPI(Context));
    120 
    121   if (getLangOpts().CPlusPlus)
    122     FieldCollector.reset(new CXXFieldCollector());
    123 
    124   // Tell diagnostics how to render things from the AST library.
    125   Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
    126 
    127   ExprEvalContexts.emplace_back(PotentiallyEvaluated, 0, CleanupInfo{}, nullptr,
    128                                 false);
    129 
    130   FunctionScopes.push_back(new FunctionScopeInfo(Diags));
    131 
    132   // Initilization of data sharing attributes stack for OpenMP
    133   InitDataSharingAttributesStack();
    134 }
    135 
    136 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
    137   DeclarationName DN = &Context.Idents.get(Name);
    138   if (IdResolver.begin(DN) == IdResolver.end())
    139     PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
    140 }
    141 
    142 void Sema::Initialize() {
    143   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
    144     SC->InitializeSema(*this);
    145 
    146   // Tell the external Sema source about this Sema object.
    147   if (ExternalSemaSource *ExternalSema
    148       = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
    149     ExternalSema->InitializeSema(*this);
    150 
    151   // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
    152   // will not be able to merge any duplicate __va_list_tag decls correctly.
    153   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
    154 
    155   if (!TUScope)
    156     return;
    157 
    158   // Initialize predefined 128-bit integer types, if needed.
    159   if (Context.getTargetInfo().hasInt128Type()) {
    160     // If either of the 128-bit integer types are unavailable to name lookup,
    161     // define them now.
    162     DeclarationName Int128 = &Context.Idents.get("__int128_t");
    163     if (IdResolver.begin(Int128) == IdResolver.end())
    164       PushOnScopeChains(Context.getInt128Decl(), TUScope);
    165 
    166     DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
    167     if (IdResolver.begin(UInt128) == IdResolver.end())
    168       PushOnScopeChains(Context.getUInt128Decl(), TUScope);
    169   }
    170 
    171 
    172   // Initialize predefined Objective-C types:
    173   if (getLangOpts().ObjC1) {
    174     // If 'SEL' does not yet refer to any declarations, make it refer to the
    175     // predefined 'SEL'.
    176     DeclarationName SEL = &Context.Idents.get("SEL");
    177     if (IdResolver.begin(SEL) == IdResolver.end())
    178       PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
    179 
    180     // If 'id' does not yet refer to any declarations, make it refer to the
    181     // predefined 'id'.
    182     DeclarationName Id = &Context.Idents.get("id");
    183     if (IdResolver.begin(Id) == IdResolver.end())
    184       PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
    185 
    186     // Create the built-in typedef for 'Class'.
    187     DeclarationName Class = &Context.Idents.get("Class");
    188     if (IdResolver.begin(Class) == IdResolver.end())
    189       PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
    190 
    191     // Create the built-in forward declaratino for 'Protocol'.
    192     DeclarationName Protocol = &Context.Idents.get("Protocol");
    193     if (IdResolver.begin(Protocol) == IdResolver.end())
    194       PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
    195   }
    196 
    197   // Create the internal type for the *StringMakeConstantString builtins.
    198   DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
    199   if (IdResolver.begin(ConstantString) == IdResolver.end())
    200     PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
    201 
    202   // Initialize Microsoft "predefined C++ types".
    203   if (getLangOpts().MSVCCompat) {
    204     if (getLangOpts().CPlusPlus &&
    205         IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
    206       PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
    207                         TUScope);
    208 
    209     addImplicitTypedef("size_t", Context.getSizeType());
    210   }
    211 
    212   // Initialize predefined OpenCL types and supported optional core features.
    213   if (getLangOpts().OpenCL) {
    214 #define OPENCLEXT(Ext) \
    215      if (Context.getTargetInfo().getSupportedOpenCLOpts().is_##Ext##_supported_core( \
    216          getLangOpts().OpenCLVersion)) \
    217        getOpenCLOptions().Ext = 1;
    218 #include "clang/Basic/OpenCLExtensions.def"
    219 
    220     addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
    221     addImplicitTypedef("event_t", Context.OCLEventTy);
    222     if (getLangOpts().OpenCLVersion >= 200) {
    223       addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
    224       addImplicitTypedef("queue_t", Context.OCLQueueTy);
    225       addImplicitTypedef("ndrange_t", Context.OCLNDRangeTy);
    226       addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
    227       addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
    228       addImplicitTypedef("atomic_uint",
    229                          Context.getAtomicType(Context.UnsignedIntTy));
    230       addImplicitTypedef("atomic_long", Context.getAtomicType(Context.LongTy));
    231       addImplicitTypedef("atomic_ulong",
    232                          Context.getAtomicType(Context.UnsignedLongTy));
    233       addImplicitTypedef("atomic_float",
    234                          Context.getAtomicType(Context.FloatTy));
    235       addImplicitTypedef("atomic_double",
    236                          Context.getAtomicType(Context.DoubleTy));
    237       // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
    238       // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
    239       addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
    240       addImplicitTypedef("atomic_intptr_t",
    241                          Context.getAtomicType(Context.getIntPtrType()));
    242       addImplicitTypedef("atomic_uintptr_t",
    243                          Context.getAtomicType(Context.getUIntPtrType()));
    244       addImplicitTypedef("atomic_size_t",
    245                          Context.getAtomicType(Context.getSizeType()));
    246       addImplicitTypedef("atomic_ptrdiff_t",
    247                          Context.getAtomicType(Context.getPointerDiffType()));
    248     }
    249   }
    250 
    251   if (Context.getTargetInfo().hasBuiltinMSVaList()) {
    252     DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
    253     if (IdResolver.begin(MSVaList) == IdResolver.end())
    254       PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
    255   }
    256 
    257   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
    258   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
    259     PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
    260 }
    261 
    262 Sema::~Sema() {
    263   llvm::DeleteContainerSeconds(LateParsedTemplateMap);
    264   if (VisContext) FreeVisContext();
    265   // Kill all the active scopes.
    266   for (unsigned I = 1, E = FunctionScopes.size(); I != E; ++I)
    267     delete FunctionScopes[I];
    268   if (FunctionScopes.size() == 1)
    269     delete FunctionScopes[0];
    270 
    271   // Tell the SemaConsumer to forget about us; we're going out of scope.
    272   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
    273     SC->ForgetSema();
    274 
    275   // Detach from the external Sema source.
    276   if (ExternalSemaSource *ExternalSema
    277         = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
    278     ExternalSema->ForgetSema();
    279 
    280   // If Sema's ExternalSource is the multiplexer - we own it.
    281   if (isMultiplexExternalSource)
    282     delete ExternalSource;
    283 
    284   threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
    285 
    286   // Destroys data sharing attributes stack for OpenMP
    287   DestroyDataSharingAttributesStack();
    288 
    289   assert(DelayedTypos.empty() && "Uncorrected typos!");
    290 }
    291 
    292 /// makeUnavailableInSystemHeader - There is an error in the current
    293 /// context.  If we're still in a system header, and we can plausibly
    294 /// make the relevant declaration unavailable instead of erroring, do
    295 /// so and return true.
    296 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
    297                                       UnavailableAttr::ImplicitReason reason) {
    298   // If we're not in a function, it's an error.
    299   FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
    300   if (!fn) return false;
    301 
    302   // If we're in template instantiation, it's an error.
    303   if (!ActiveTemplateInstantiations.empty())
    304     return false;
    305 
    306   // If that function's not in a system header, it's an error.
    307   if (!Context.getSourceManager().isInSystemHeader(loc))
    308     return false;
    309 
    310   // If the function is already unavailable, it's not an error.
    311   if (fn->hasAttr<UnavailableAttr>()) return true;
    312 
    313   fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
    314   return true;
    315 }
    316 
    317 ASTMutationListener *Sema::getASTMutationListener() const {
    318   return getASTConsumer().GetASTMutationListener();
    319 }
    320 
    321 ///\brief Registers an external source. If an external source already exists,
    322 /// creates a multiplex external source and appends to it.
    323 ///
    324 ///\param[in] E - A non-null external sema source.
    325 ///
    326 void Sema::addExternalSource(ExternalSemaSource *E) {
    327   assert(E && "Cannot use with NULL ptr");
    328 
    329   if (!ExternalSource) {
    330     ExternalSource = E;
    331     return;
    332   }
    333 
    334   if (isMultiplexExternalSource)
    335     static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
    336   else {
    337     ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
    338     isMultiplexExternalSource = true;
    339   }
    340 }
    341 
    342 /// \brief Print out statistics about the semantic analysis.
    343 void Sema::PrintStats() const {
    344   llvm::errs() << "\n*** Semantic Analysis Stats:\n";
    345   llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
    346 
    347   BumpAlloc.PrintStats();
    348   AnalysisWarnings.PrintStats();
    349 }
    350 
    351 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
    352                                                QualType SrcType,
    353                                                SourceLocation Loc) {
    354   Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
    355   if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
    356     return;
    357 
    358   Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
    359   if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
    360     return;
    361 
    362   Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
    363 }
    364 
    365 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
    366 /// If there is already an implicit cast, merge into the existing one.
    367 /// The result is of the given category.
    368 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
    369                                    CastKind Kind, ExprValueKind VK,
    370                                    const CXXCastPath *BasePath,
    371                                    CheckedConversionKind CCK) {
    372 #ifndef NDEBUG
    373   if (VK == VK_RValue && !E->isRValue()) {
    374     switch (Kind) {
    375     default:
    376       llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
    377                        "kind");
    378     case CK_LValueToRValue:
    379     case CK_ArrayToPointerDecay:
    380     case CK_FunctionToPointerDecay:
    381     case CK_ToVoid:
    382       break;
    383     }
    384   }
    385   assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
    386 #endif
    387 
    388   diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getLocStart());
    389 
    390   QualType ExprTy = Context.getCanonicalType(E->getType());
    391   QualType TypeTy = Context.getCanonicalType(Ty);
    392 
    393   if (ExprTy == TypeTy)
    394     return E;
    395 
    396   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
    397     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
    398       ImpCast->setType(Ty);
    399       ImpCast->setValueKind(VK);
    400       return E;
    401     }
    402   }
    403 
    404   return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
    405 }
    406 
    407 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
    408 /// to the conversion from scalar type ScalarTy to the Boolean type.
    409 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
    410   switch (ScalarTy->getScalarTypeKind()) {
    411   case Type::STK_Bool: return CK_NoOp;
    412   case Type::STK_CPointer: return CK_PointerToBoolean;
    413   case Type::STK_BlockPointer: return CK_PointerToBoolean;
    414   case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
    415   case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
    416   case Type::STK_Integral: return CK_IntegralToBoolean;
    417   case Type::STK_Floating: return CK_FloatingToBoolean;
    418   case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
    419   case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
    420   }
    421   return CK_Invalid;
    422 }
    423 
    424 /// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
    425 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
    426   if (D->getMostRecentDecl()->isUsed())
    427     return true;
    428 
    429   if (D->isExternallyVisible())
    430     return true;
    431 
    432   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    433     // UnusedFileScopedDecls stores the first declaration.
    434     // The declaration may have become definition so check again.
    435     const FunctionDecl *DeclToCheck;
    436     if (FD->hasBody(DeclToCheck))
    437       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    438 
    439     // Later redecls may add new information resulting in not having to warn,
    440     // so check again.
    441     DeclToCheck = FD->getMostRecentDecl();
    442     if (DeclToCheck != FD)
    443       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    444   }
    445 
    446   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
    447     // If a variable usable in constant expressions is referenced,
    448     // don't warn if it isn't used: if the value of a variable is required
    449     // for the computation of a constant expression, it doesn't make sense to
    450     // warn even if the variable isn't odr-used.  (isReferenced doesn't
    451     // precisely reflect that, but it's a decent approximation.)
    452     if (VD->isReferenced() &&
    453         VD->isUsableInConstantExpressions(SemaRef->Context))
    454       return true;
    455 
    456     // UnusedFileScopedDecls stores the first declaration.
    457     // The declaration may have become definition so check again.
    458     const VarDecl *DeclToCheck = VD->getDefinition();
    459     if (DeclToCheck)
    460       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    461 
    462     // Later redecls may add new information resulting in not having to warn,
    463     // so check again.
    464     DeclToCheck = VD->getMostRecentDecl();
    465     if (DeclToCheck != VD)
    466       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
    467   }
    468 
    469   return false;
    470 }
    471 
    472 /// Obtains a sorted list of functions and variables that are undefined but
    473 /// ODR-used.
    474 void Sema::getUndefinedButUsed(
    475     SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
    476   for (const auto &UndefinedUse : UndefinedButUsed) {
    477     NamedDecl *ND = UndefinedUse.first;
    478 
    479     // Ignore attributes that have become invalid.
    480     if (ND->isInvalidDecl()) continue;
    481 
    482     // __attribute__((weakref)) is basically a definition.
    483     if (ND->hasAttr<WeakRefAttr>()) continue;
    484 
    485     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
    486       if (FD->isDefined())
    487         continue;
    488       if (FD->isExternallyVisible() &&
    489           !FD->getMostRecentDecl()->isInlined())
    490         continue;
    491     } else {
    492       auto *VD = cast<VarDecl>(ND);
    493       if (VD->hasDefinition() != VarDecl::DeclarationOnly)
    494         continue;
    495       if (VD->isExternallyVisible() && !VD->getMostRecentDecl()->isInline())
    496         continue;
    497     }
    498 
    499     Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
    500   }
    501 }
    502 
    503 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
    504 /// or that are inline.
    505 static void checkUndefinedButUsed(Sema &S) {
    506   if (S.UndefinedButUsed.empty()) return;
    507 
    508   // Collect all the still-undefined entities with internal linkage.
    509   SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
    510   S.getUndefinedButUsed(Undefined);
    511   if (Undefined.empty()) return;
    512 
    513   for (SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> >::iterator
    514          I = Undefined.begin(), E = Undefined.end(); I != E; ++I) {
    515     NamedDecl *ND = I->first;
    516 
    517     if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
    518       // An exported function will always be emitted when defined, so even if
    519       // the function is inline, it doesn't have to be emitted in this TU. An
    520       // imported function implies that it has been exported somewhere else.
    521       continue;
    522     }
    523 
    524     if (!ND->isExternallyVisible()) {
    525       S.Diag(ND->getLocation(), diag::warn_undefined_internal)
    526         << isa<VarDecl>(ND) << ND;
    527     } else if (auto *FD = dyn_cast<FunctionDecl>(ND)) {
    528       (void)FD;
    529       assert(FD->getMostRecentDecl()->isInlined() &&
    530              "used object requires definition but isn't inline or internal?");
    531       // FIXME: This is ill-formed; we should reject.
    532       S.Diag(ND->getLocation(), diag::warn_undefined_inline) << ND;
    533     } else {
    534       assert(cast<VarDecl>(ND)->getMostRecentDecl()->isInline() &&
    535              "used var requires definition but isn't inline or internal?");
    536       S.Diag(ND->getLocation(), diag::err_undefined_inline_var) << ND;
    537     }
    538     if (I->second.isValid())
    539       S.Diag(I->second, diag::note_used_here);
    540   }
    541 
    542   S.UndefinedButUsed.clear();
    543 }
    544 
    545 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
    546   if (!ExternalSource)
    547     return;
    548 
    549   SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
    550   ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
    551   for (auto &WeakID : WeakIDs)
    552     WeakUndeclaredIdentifiers.insert(WeakID);
    553 }
    554 
    555 
    556 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
    557 
    558 /// \brief Returns true, if all methods and nested classes of the given
    559 /// CXXRecordDecl are defined in this translation unit.
    560 ///
    561 /// Should only be called from ActOnEndOfTranslationUnit so that all
    562 /// definitions are actually read.
    563 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
    564                                             RecordCompleteMap &MNCComplete) {
    565   RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
    566   if (Cache != MNCComplete.end())
    567     return Cache->second;
    568   if (!RD->isCompleteDefinition())
    569     return false;
    570   bool Complete = true;
    571   for (DeclContext::decl_iterator I = RD->decls_begin(),
    572                                   E = RD->decls_end();
    573        I != E && Complete; ++I) {
    574     if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
    575       Complete = M->isDefined() || (M->isPure() && !isa<CXXDestructorDecl>(M));
    576     else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
    577       // If the template function is marked as late template parsed at this
    578       // point, it has not been instantiated and therefore we have not
    579       // performed semantic analysis on it yet, so we cannot know if the type
    580       // can be considered complete.
    581       Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
    582                   F->getTemplatedDecl()->isDefined();
    583     else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
    584       if (R->isInjectedClassName())
    585         continue;
    586       if (R->hasDefinition())
    587         Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
    588                                                    MNCComplete);
    589       else
    590         Complete = false;
    591     }
    592   }
    593   MNCComplete[RD] = Complete;
    594   return Complete;
    595 }
    596 
    597 /// \brief Returns true, if the given CXXRecordDecl is fully defined in this
    598 /// translation unit, i.e. all methods are defined or pure virtual and all
    599 /// friends, friend functions and nested classes are fully defined in this
    600 /// translation unit.
    601 ///
    602 /// Should only be called from ActOnEndOfTranslationUnit so that all
    603 /// definitions are actually read.
    604 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
    605                                  RecordCompleteMap &RecordsComplete,
    606                                  RecordCompleteMap &MNCComplete) {
    607   RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
    608   if (Cache != RecordsComplete.end())
    609     return Cache->second;
    610   bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
    611   for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
    612                                       E = RD->friend_end();
    613        I != E && Complete; ++I) {
    614     // Check if friend classes and methods are complete.
    615     if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
    616       // Friend classes are available as the TypeSourceInfo of the FriendDecl.
    617       if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
    618         Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
    619       else
    620         Complete = false;
    621     } else {
    622       // Friend functions are available through the NamedDecl of FriendDecl.
    623       if (const FunctionDecl *FD =
    624           dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
    625         Complete = FD->isDefined();
    626       else
    627         // This is a template friend, give up.
    628         Complete = false;
    629     }
    630   }
    631   RecordsComplete[RD] = Complete;
    632   return Complete;
    633 }
    634 
    635 void Sema::emitAndClearUnusedLocalTypedefWarnings() {
    636   if (ExternalSource)
    637     ExternalSource->ReadUnusedLocalTypedefNameCandidates(
    638         UnusedLocalTypedefNameCandidates);
    639   for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
    640     if (TD->isReferenced())
    641       continue;
    642     Diag(TD->getLocation(), diag::warn_unused_local_typedef)
    643         << isa<TypeAliasDecl>(TD) << TD->getDeclName();
    644   }
    645   UnusedLocalTypedefNameCandidates.clear();
    646 }
    647 
    648 /// ActOnEndOfTranslationUnit - This is called at the very end of the
    649 /// translation unit when EOF is reached and all but the top-level scope is
    650 /// popped.
    651 void Sema::ActOnEndOfTranslationUnit() {
    652   assert(DelayedDiagnostics.getCurrentPool() == nullptr
    653          && "reached end of translation unit with a pool attached?");
    654 
    655   // If code completion is enabled, don't perform any end-of-translation-unit
    656   // work.
    657   if (PP.isCodeCompletionEnabled())
    658     return;
    659 
    660   // Complete translation units and modules define vtables and perform implicit
    661   // instantiations. PCH files do not.
    662   if (TUKind != TU_Prefix) {
    663     DiagnoseUseOfUnimplementedSelectors();
    664 
    665     // If DefinedUsedVTables ends up marking any virtual member functions it
    666     // might lead to more pending template instantiations, which we then need
    667     // to instantiate.
    668     DefineUsedVTables();
    669 
    670     // C++: Perform implicit template instantiations.
    671     //
    672     // FIXME: When we perform these implicit instantiations, we do not
    673     // carefully keep track of the point of instantiation (C++ [temp.point]).
    674     // This means that name lookup that occurs within the template
    675     // instantiation will always happen at the end of the translation unit,
    676     // so it will find some names that are not required to be found. This is
    677     // valid, but we could do better by diagnosing if an instantiation uses a
    678     // name that was not visible at its first point of instantiation.
    679     if (ExternalSource) {
    680       // Load pending instantiations from the external source.
    681       SmallVector<PendingImplicitInstantiation, 4> Pending;
    682       ExternalSource->ReadPendingInstantiations(Pending);
    683       PendingInstantiations.insert(PendingInstantiations.begin(),
    684                                    Pending.begin(), Pending.end());
    685     }
    686     PerformPendingInstantiations();
    687 
    688     if (LateTemplateParserCleanup)
    689       LateTemplateParserCleanup(OpaqueParser);
    690 
    691     CheckDelayedMemberExceptionSpecs();
    692   }
    693 
    694   // All delayed member exception specs should be checked or we end up accepting
    695   // incompatible declarations.
    696   // FIXME: This is wrong for TUKind == TU_Prefix. In that case, we need to
    697   // write out the lists to the AST file (if any).
    698   assert(DelayedDefaultedMemberExceptionSpecs.empty());
    699   assert(DelayedExceptionSpecChecks.empty());
    700 
    701   // All dllexport classes should have been processed already.
    702   assert(DelayedDllExportClasses.empty());
    703 
    704   // Remove file scoped decls that turned out to be used.
    705   UnusedFileScopedDecls.erase(
    706       std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
    707                      UnusedFileScopedDecls.end(),
    708                      std::bind1st(std::ptr_fun(ShouldRemoveFromUnused), this)),
    709       UnusedFileScopedDecls.end());
    710 
    711   if (TUKind == TU_Prefix) {
    712     // Translation unit prefixes don't need any of the checking below.
    713     TUScope = nullptr;
    714     return;
    715   }
    716 
    717   // Check for #pragma weak identifiers that were never declared
    718   LoadExternalWeakUndeclaredIdentifiers();
    719   for (auto WeakID : WeakUndeclaredIdentifiers) {
    720     if (WeakID.second.getUsed())
    721       continue;
    722 
    723     Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
    724                                       LookupOrdinaryName);
    725     if (PrevDecl != nullptr &&
    726         !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
    727       Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
    728           << "'weak'" << ExpectedVariableOrFunction;
    729     else
    730       Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
    731           << WeakID.first;
    732   }
    733 
    734   if (LangOpts.CPlusPlus11 &&
    735       !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
    736     CheckDelegatingCtorCycles();
    737 
    738   if (!Diags.hasErrorOccurred()) {
    739     if (ExternalSource)
    740       ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
    741     checkUndefinedButUsed(*this);
    742   }
    743 
    744   if (TUKind == TU_Module) {
    745     // If we are building a module, resolve all of the exported declarations
    746     // now.
    747     if (Module *CurrentModule = PP.getCurrentModule()) {
    748       ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
    749 
    750       SmallVector<Module *, 2> Stack;
    751       Stack.push_back(CurrentModule);
    752       while (!Stack.empty()) {
    753         Module *Mod = Stack.pop_back_val();
    754 
    755         // Resolve the exported declarations and conflicts.
    756         // FIXME: Actually complain, once we figure out how to teach the
    757         // diagnostic client to deal with complaints in the module map at this
    758         // point.
    759         ModMap.resolveExports(Mod, /*Complain=*/false);
    760         ModMap.resolveUses(Mod, /*Complain=*/false);
    761         ModMap.resolveConflicts(Mod, /*Complain=*/false);
    762 
    763         // Queue the submodules, so their exports will also be resolved.
    764         Stack.append(Mod->submodule_begin(), Mod->submodule_end());
    765       }
    766     }
    767 
    768     // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
    769     // modules when they are built, not every time they are used.
    770     emitAndClearUnusedLocalTypedefWarnings();
    771 
    772     // Modules don't need any of the checking below.
    773     TUScope = nullptr;
    774     return;
    775   }
    776 
    777   // C99 6.9.2p2:
    778   //   A declaration of an identifier for an object that has file
    779   //   scope without an initializer, and without a storage-class
    780   //   specifier or with the storage-class specifier static,
    781   //   constitutes a tentative definition. If a translation unit
    782   //   contains one or more tentative definitions for an identifier,
    783   //   and the translation unit contains no external definition for
    784   //   that identifier, then the behavior is exactly as if the
    785   //   translation unit contains a file scope declaration of that
    786   //   identifier, with the composite type as of the end of the
    787   //   translation unit, with an initializer equal to 0.
    788   llvm::SmallSet<VarDecl *, 32> Seen;
    789   for (TentativeDefinitionsType::iterator
    790             T = TentativeDefinitions.begin(ExternalSource),
    791          TEnd = TentativeDefinitions.end();
    792        T != TEnd; ++T)
    793   {
    794     VarDecl *VD = (*T)->getActingDefinition();
    795 
    796     // If the tentative definition was completed, getActingDefinition() returns
    797     // null. If we've already seen this variable before, insert()'s second
    798     // return value is false.
    799     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
    800       continue;
    801 
    802     if (const IncompleteArrayType *ArrayT
    803         = Context.getAsIncompleteArrayType(VD->getType())) {
    804       // Set the length of the array to 1 (C99 6.9.2p5).
    805       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
    806       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
    807       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
    808                                                 One, ArrayType::Normal, 0);
    809       VD->setType(T);
    810     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
    811                                    diag::err_tentative_def_incomplete_type))
    812       VD->setInvalidDecl();
    813 
    814     CheckCompleteVariableDeclaration(VD);
    815 
    816     // Notify the consumer that we've completed a tentative definition.
    817     if (!VD->isInvalidDecl())
    818       Consumer.CompleteTentativeDefinition(VD);
    819 
    820   }
    821 
    822   // If there were errors, disable 'unused' warnings since they will mostly be
    823   // noise.
    824   if (!Diags.hasErrorOccurred()) {
    825     // Output warning for unused file scoped decls.
    826     for (UnusedFileScopedDeclsType::iterator
    827            I = UnusedFileScopedDecls.begin(ExternalSource),
    828            E = UnusedFileScopedDecls.end(); I != E; ++I) {
    829       if (ShouldRemoveFromUnused(this, *I))
    830         continue;
    831 
    832       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
    833         const FunctionDecl *DiagD;
    834         if (!FD->hasBody(DiagD))
    835           DiagD = FD;
    836         if (DiagD->isDeleted())
    837           continue; // Deleted functions are supposed to be unused.
    838         if (DiagD->isReferenced()) {
    839           if (isa<CXXMethodDecl>(DiagD))
    840             Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
    841                   << DiagD->getDeclName();
    842           else {
    843             if (FD->getStorageClass() == SC_Static &&
    844                 !FD->isInlineSpecified() &&
    845                 !SourceMgr.isInMainFile(
    846                    SourceMgr.getExpansionLoc(FD->getLocation())))
    847               Diag(DiagD->getLocation(),
    848                    diag::warn_unneeded_static_internal_decl)
    849                   << DiagD->getDeclName();
    850             else
    851               Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
    852                    << /*function*/0 << DiagD->getDeclName();
    853           }
    854         } else {
    855           Diag(DiagD->getLocation(),
    856                isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
    857                                          : diag::warn_unused_function)
    858                 << DiagD->getDeclName();
    859         }
    860       } else {
    861         const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
    862         if (!DiagD)
    863           DiagD = cast<VarDecl>(*I);
    864         if (DiagD->isReferenced()) {
    865           Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
    866                 << /*variable*/1 << DiagD->getDeclName();
    867         } else if (DiagD->getType().isConstQualified()) {
    868           Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
    869               << DiagD->getDeclName();
    870         } else {
    871           Diag(DiagD->getLocation(), diag::warn_unused_variable)
    872               << DiagD->getDeclName();
    873         }
    874       }
    875     }
    876 
    877     emitAndClearUnusedLocalTypedefWarnings();
    878   }
    879 
    880   if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
    881     RecordCompleteMap RecordsComplete;
    882     RecordCompleteMap MNCComplete;
    883     for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
    884          E = UnusedPrivateFields.end(); I != E; ++I) {
    885       const NamedDecl *D = *I;
    886       const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
    887       if (RD && !RD->isUnion() &&
    888           IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
    889         Diag(D->getLocation(), diag::warn_unused_private_field)
    890               << D->getDeclName();
    891       }
    892     }
    893   }
    894 
    895   if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
    896     if (ExternalSource)
    897       ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
    898     for (const auto &DeletedFieldInfo : DeleteExprs) {
    899       for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
    900         AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
    901                                   DeleteExprLoc.second);
    902       }
    903     }
    904   }
    905 
    906   // Check we've noticed that we're no longer parsing the initializer for every
    907   // variable. If we miss cases, then at best we have a performance issue and
    908   // at worst a rejects-valid bug.
    909   assert(ParsingInitForAutoVars.empty() &&
    910          "Didn't unmark var as having its initializer parsed");
    911 
    912   TUScope = nullptr;
    913 }
    914 
    915 
    916 //===----------------------------------------------------------------------===//
    917 // Helper functions.
    918 //===----------------------------------------------------------------------===//
    919 
    920 DeclContext *Sema::getFunctionLevelDeclContext() {
    921   DeclContext *DC = CurContext;
    922 
    923   while (true) {
    924     if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
    925       DC = DC->getParent();
    926     } else if (isa<CXXMethodDecl>(DC) &&
    927                cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
    928                cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
    929       DC = DC->getParent()->getParent();
    930     }
    931     else break;
    932   }
    933 
    934   return DC;
    935 }
    936 
    937 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
    938 /// to the function decl for the function being parsed.  If we're currently
    939 /// in a 'block', this returns the containing context.
    940 FunctionDecl *Sema::getCurFunctionDecl() {
    941   DeclContext *DC = getFunctionLevelDeclContext();
    942   return dyn_cast<FunctionDecl>(DC);
    943 }
    944 
    945 ObjCMethodDecl *Sema::getCurMethodDecl() {
    946   DeclContext *DC = getFunctionLevelDeclContext();
    947   while (isa<RecordDecl>(DC))
    948     DC = DC->getParent();
    949   return dyn_cast<ObjCMethodDecl>(DC);
    950 }
    951 
    952 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
    953   DeclContext *DC = getFunctionLevelDeclContext();
    954   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
    955     return cast<NamedDecl>(DC);
    956   return nullptr;
    957 }
    958 
    959 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
    960   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
    961   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
    962   // been made more painfully obvious by the refactor that introduced this
    963   // function, but it is possible that the incoming argument can be
    964   // eliminnated. If it truly cannot be (for example, there is some reentrancy
    965   // issue I am not seeing yet), then there should at least be a clarifying
    966   // comment somewhere.
    967   if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
    968     switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
    969               Diags.getCurrentDiagID())) {
    970     case DiagnosticIDs::SFINAE_Report:
    971       // We'll report the diagnostic below.
    972       break;
    973 
    974     case DiagnosticIDs::SFINAE_SubstitutionFailure:
    975       // Count this failure so that we know that template argument deduction
    976       // has failed.
    977       ++NumSFINAEErrors;
    978 
    979       // Make a copy of this suppressed diagnostic and store it with the
    980       // template-deduction information.
    981       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
    982         Diagnostic DiagInfo(&Diags);
    983         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
    984                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
    985       }
    986 
    987       Diags.setLastDiagnosticIgnored();
    988       Diags.Clear();
    989       return;
    990 
    991     case DiagnosticIDs::SFINAE_AccessControl: {
    992       // Per C++ Core Issue 1170, access control is part of SFINAE.
    993       // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
    994       // make access control a part of SFINAE for the purposes of checking
    995       // type traits.
    996       if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
    997         break;
    998 
    999       SourceLocation Loc = Diags.getCurrentDiagLoc();
   1000 
   1001       // Suppress this diagnostic.
   1002       ++NumSFINAEErrors;
   1003 
   1004       // Make a copy of this suppressed diagnostic and store it with the
   1005       // template-deduction information.
   1006       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
   1007         Diagnostic DiagInfo(&Diags);
   1008         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
   1009                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
   1010       }
   1011 
   1012       Diags.setLastDiagnosticIgnored();
   1013       Diags.Clear();
   1014 
   1015       // Now the diagnostic state is clear, produce a C++98 compatibility
   1016       // warning.
   1017       Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
   1018 
   1019       // The last diagnostic which Sema produced was ignored. Suppress any
   1020       // notes attached to it.
   1021       Diags.setLastDiagnosticIgnored();
   1022       return;
   1023     }
   1024 
   1025     case DiagnosticIDs::SFINAE_Suppress:
   1026       // Make a copy of this suppressed diagnostic and store it with the
   1027       // template-deduction information;
   1028       if (*Info) {
   1029         Diagnostic DiagInfo(&Diags);
   1030         (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
   1031                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
   1032       }
   1033 
   1034       // Suppress this diagnostic.
   1035       Diags.setLastDiagnosticIgnored();
   1036       Diags.Clear();
   1037       return;
   1038     }
   1039   }
   1040 
   1041   // Set up the context's printing policy based on our current state.
   1042   Context.setPrintingPolicy(getPrintingPolicy());
   1043 
   1044   // Emit the diagnostic.
   1045   if (!Diags.EmitCurrentDiagnostic())
   1046     return;
   1047 
   1048   // If this is not a note, and we're in a template instantiation
   1049   // that is different from the last template instantiation where
   1050   // we emitted an error, print a template instantiation
   1051   // backtrace.
   1052   if (!DiagnosticIDs::isBuiltinNote(DiagID) &&
   1053       !ActiveTemplateInstantiations.empty() &&
   1054       ActiveTemplateInstantiations.back()
   1055         != LastTemplateInstantiationErrorContext) {
   1056     PrintInstantiationStack();
   1057     LastTemplateInstantiationErrorContext = ActiveTemplateInstantiations.back();
   1058   }
   1059 }
   1060 
   1061 Sema::SemaDiagnosticBuilder
   1062 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
   1063   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
   1064   PD.Emit(Builder);
   1065 
   1066   return Builder;
   1067 }
   1068 
   1069 /// \brief Looks through the macro-expansion chain for the given
   1070 /// location, looking for a macro expansion with the given name.
   1071 /// If one is found, returns true and sets the location to that
   1072 /// expansion loc.
   1073 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
   1074   SourceLocation loc = locref;
   1075   if (!loc.isMacroID()) return false;
   1076 
   1077   // There's no good way right now to look at the intermediate
   1078   // expansions, so just jump to the expansion location.
   1079   loc = getSourceManager().getExpansionLoc(loc);
   1080 
   1081   // If that's written with the name, stop here.
   1082   SmallVector<char, 16> buffer;
   1083   if (getPreprocessor().getSpelling(loc, buffer) == name) {
   1084     locref = loc;
   1085     return true;
   1086   }
   1087   return false;
   1088 }
   1089 
   1090 /// \brief Determines the active Scope associated with the given declaration
   1091 /// context.
   1092 ///
   1093 /// This routine maps a declaration context to the active Scope object that
   1094 /// represents that declaration context in the parser. It is typically used
   1095 /// from "scope-less" code (e.g., template instantiation, lazy creation of
   1096 /// declarations) that injects a name for name-lookup purposes and, therefore,
   1097 /// must update the Scope.
   1098 ///
   1099 /// \returns The scope corresponding to the given declaraion context, or NULL
   1100 /// if no such scope is open.
   1101 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
   1102 
   1103   if (!Ctx)
   1104     return nullptr;
   1105 
   1106   Ctx = Ctx->getPrimaryContext();
   1107   for (Scope *S = getCurScope(); S; S = S->getParent()) {
   1108     // Ignore scopes that cannot have declarations. This is important for
   1109     // out-of-line definitions of static class members.
   1110     if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
   1111       if (DeclContext *Entity = S->getEntity())
   1112         if (Ctx == Entity->getPrimaryContext())
   1113           return S;
   1114   }
   1115 
   1116   return nullptr;
   1117 }
   1118 
   1119 /// \brief Enter a new function scope
   1120 void Sema::PushFunctionScope() {
   1121   if (FunctionScopes.size() == 1) {
   1122     // Use the "top" function scope rather than having to allocate
   1123     // memory for a new scope.
   1124     FunctionScopes.back()->Clear();
   1125     FunctionScopes.push_back(FunctionScopes.back());
   1126     return;
   1127   }
   1128 
   1129   FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
   1130 }
   1131 
   1132 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
   1133   FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
   1134                                               BlockScope, Block));
   1135 }
   1136 
   1137 LambdaScopeInfo *Sema::PushLambdaScope() {
   1138   LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
   1139   FunctionScopes.push_back(LSI);
   1140   return LSI;
   1141 }
   1142 
   1143 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
   1144   if (LambdaScopeInfo *const LSI = getCurLambda()) {
   1145     LSI->AutoTemplateParameterDepth = Depth;
   1146     return;
   1147   }
   1148   llvm_unreachable(
   1149       "Remove assertion if intentionally called in a non-lambda context.");
   1150 }
   1151 
   1152 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
   1153                                 const Decl *D, const BlockExpr *blkExpr) {
   1154   FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
   1155   assert(!FunctionScopes.empty() && "mismatched push/pop!");
   1156 
   1157   // Issue any analysis-based warnings.
   1158   if (WP && D)
   1159     AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
   1160   else
   1161     for (const auto &PUD : Scope->PossiblyUnreachableDiags)
   1162       Diag(PUD.Loc, PUD.PD);
   1163 
   1164   if (FunctionScopes.back() != Scope)
   1165     delete Scope;
   1166 }
   1167 
   1168 void Sema::PushCompoundScope() {
   1169   getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo());
   1170 }
   1171 
   1172 void Sema::PopCompoundScope() {
   1173   FunctionScopeInfo *CurFunction = getCurFunction();
   1174   assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
   1175 
   1176   CurFunction->CompoundScopes.pop_back();
   1177 }
   1178 
   1179 /// \brief Determine whether any errors occurred within this function/method/
   1180 /// block.
   1181 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
   1182   return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
   1183 }
   1184 
   1185 BlockScopeInfo *Sema::getCurBlock() {
   1186   if (FunctionScopes.empty())
   1187     return nullptr;
   1188 
   1189   auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
   1190   if (CurBSI && CurBSI->TheDecl &&
   1191       !CurBSI->TheDecl->Encloses(CurContext)) {
   1192     // We have switched contexts due to template instantiation.
   1193     assert(!ActiveTemplateInstantiations.empty());
   1194     return nullptr;
   1195   }
   1196 
   1197   return CurBSI;
   1198 }
   1199 
   1200 LambdaScopeInfo *Sema::getCurLambda() {
   1201   if (FunctionScopes.empty())
   1202     return nullptr;
   1203 
   1204   auto CurLSI = dyn_cast<LambdaScopeInfo>(FunctionScopes.back());
   1205   if (CurLSI && CurLSI->Lambda &&
   1206       !CurLSI->Lambda->Encloses(CurContext)) {
   1207     // We have switched contexts due to template instantiation.
   1208     assert(!ActiveTemplateInstantiations.empty());
   1209     return nullptr;
   1210   }
   1211 
   1212   return CurLSI;
   1213 }
   1214 // We have a generic lambda if we parsed auto parameters, or we have
   1215 // an associated template parameter list.
   1216 LambdaScopeInfo *Sema::getCurGenericLambda() {
   1217   if (LambdaScopeInfo *LSI =  getCurLambda()) {
   1218     return (LSI->AutoTemplateParams.size() ||
   1219                     LSI->GLTemplateParameterList) ? LSI : nullptr;
   1220   }
   1221   return nullptr;
   1222 }
   1223 
   1224 
   1225 void Sema::ActOnComment(SourceRange Comment) {
   1226   if (!LangOpts.RetainCommentsFromSystemHeaders &&
   1227       SourceMgr.isInSystemHeader(Comment.getBegin()))
   1228     return;
   1229   RawComment RC(SourceMgr, Comment, false,
   1230                 LangOpts.CommentOpts.ParseAllComments);
   1231   if (RC.isAlmostTrailingComment()) {
   1232     SourceRange MagicMarkerRange(Comment.getBegin(),
   1233                                  Comment.getBegin().getLocWithOffset(3));
   1234     StringRef MagicMarkerText;
   1235     switch (RC.getKind()) {
   1236     case RawComment::RCK_OrdinaryBCPL:
   1237       MagicMarkerText = "///<";
   1238       break;
   1239     case RawComment::RCK_OrdinaryC:
   1240       MagicMarkerText = "/**<";
   1241       break;
   1242     default:
   1243       llvm_unreachable("if this is an almost Doxygen comment, "
   1244                        "it should be ordinary");
   1245     }
   1246     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
   1247       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
   1248   }
   1249   Context.addComment(RC);
   1250 }
   1251 
   1252 // Pin this vtable to this file.
   1253 ExternalSemaSource::~ExternalSemaSource() {}
   1254 
   1255 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
   1256 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
   1257 
   1258 void ExternalSemaSource::ReadKnownNamespaces(
   1259                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
   1260 }
   1261 
   1262 void ExternalSemaSource::ReadUndefinedButUsed(
   1263     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
   1264 
   1265 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
   1266     FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
   1267 
   1268 void PrettyDeclStackTraceEntry::print(raw_ostream &OS) const {
   1269   SourceLocation Loc = this->Loc;
   1270   if (!Loc.isValid() && TheDecl) Loc = TheDecl->getLocation();
   1271   if (Loc.isValid()) {
   1272     Loc.print(OS, S.getSourceManager());
   1273     OS << ": ";
   1274   }
   1275   OS << Message;
   1276 
   1277   if (auto *ND = dyn_cast_or_null<NamedDecl>(TheDecl)) {
   1278     OS << " '";
   1279     ND->getNameForDiagnostic(OS, ND->getASTContext().getPrintingPolicy(), true);
   1280     OS << "'";
   1281   }
   1282 
   1283   OS << '\n';
   1284 }
   1285 
   1286 /// \brief Figure out if an expression could be turned into a call.
   1287 ///
   1288 /// Use this when trying to recover from an error where the programmer may have
   1289 /// written just the name of a function instead of actually calling it.
   1290 ///
   1291 /// \param E - The expression to examine.
   1292 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
   1293 ///  with no arguments, this parameter is set to the type returned by such a
   1294 ///  call; otherwise, it is set to an empty QualType.
   1295 /// \param OverloadSet - If the expression is an overloaded function
   1296 ///  name, this parameter is populated with the decls of the various overloads.
   1297 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
   1298                          UnresolvedSetImpl &OverloadSet) {
   1299   ZeroArgCallReturnTy = QualType();
   1300   OverloadSet.clear();
   1301 
   1302   const OverloadExpr *Overloads = nullptr;
   1303   bool IsMemExpr = false;
   1304   if (E.getType() == Context.OverloadTy) {
   1305     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
   1306 
   1307     // Ignore overloads that are pointer-to-member constants.
   1308     if (FR.HasFormOfMemberPointer)
   1309       return false;
   1310 
   1311     Overloads = FR.Expression;
   1312   } else if (E.getType() == Context.BoundMemberTy) {
   1313     Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
   1314     IsMemExpr = true;
   1315   }
   1316 
   1317   bool Ambiguous = false;
   1318 
   1319   if (Overloads) {
   1320     for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
   1321          DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
   1322       OverloadSet.addDecl(*it);
   1323 
   1324       // Check whether the function is a non-template, non-member which takes no
   1325       // arguments.
   1326       if (IsMemExpr)
   1327         continue;
   1328       if (const FunctionDecl *OverloadDecl
   1329             = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
   1330         if (OverloadDecl->getMinRequiredArguments() == 0) {
   1331           if (!ZeroArgCallReturnTy.isNull() && !Ambiguous) {
   1332             ZeroArgCallReturnTy = QualType();
   1333             Ambiguous = true;
   1334           } else
   1335             ZeroArgCallReturnTy = OverloadDecl->getReturnType();
   1336         }
   1337       }
   1338     }
   1339 
   1340     // If it's not a member, use better machinery to try to resolve the call
   1341     if (!IsMemExpr)
   1342       return !ZeroArgCallReturnTy.isNull();
   1343   }
   1344 
   1345   // Attempt to call the member with no arguments - this will correctly handle
   1346   // member templates with defaults/deduction of template arguments, overloads
   1347   // with default arguments, etc.
   1348   if (IsMemExpr && !E.isTypeDependent()) {
   1349     bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
   1350     getDiagnostics().setSuppressAllDiagnostics(true);
   1351     ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
   1352                                              None, SourceLocation());
   1353     getDiagnostics().setSuppressAllDiagnostics(Suppress);
   1354     if (R.isUsable()) {
   1355       ZeroArgCallReturnTy = R.get()->getType();
   1356       return true;
   1357     }
   1358     return false;
   1359   }
   1360 
   1361   if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
   1362     if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
   1363       if (Fun->getMinRequiredArguments() == 0)
   1364         ZeroArgCallReturnTy = Fun->getReturnType();
   1365       return true;
   1366     }
   1367   }
   1368 
   1369   // We don't have an expression that's convenient to get a FunctionDecl from,
   1370   // but we can at least check if the type is "function of 0 arguments".
   1371   QualType ExprTy = E.getType();
   1372   const FunctionType *FunTy = nullptr;
   1373   QualType PointeeTy = ExprTy->getPointeeType();
   1374   if (!PointeeTy.isNull())
   1375     FunTy = PointeeTy->getAs<FunctionType>();
   1376   if (!FunTy)
   1377     FunTy = ExprTy->getAs<FunctionType>();
   1378 
   1379   if (const FunctionProtoType *FPT =
   1380       dyn_cast_or_null<FunctionProtoType>(FunTy)) {
   1381     if (FPT->getNumParams() == 0)
   1382       ZeroArgCallReturnTy = FunTy->getReturnType();
   1383     return true;
   1384   }
   1385   return false;
   1386 }
   1387 
   1388 /// \brief Give notes for a set of overloads.
   1389 ///
   1390 /// A companion to tryExprAsCall. In cases when the name that the programmer
   1391 /// wrote was an overloaded function, we may be able to make some guesses about
   1392 /// plausible overloads based on their return types; such guesses can be handed
   1393 /// off to this method to be emitted as notes.
   1394 ///
   1395 /// \param Overloads - The overloads to note.
   1396 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
   1397 ///  -fshow-overloads=best, this is the location to attach to the note about too
   1398 ///  many candidates. Typically this will be the location of the original
   1399 ///  ill-formed expression.
   1400 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
   1401                           const SourceLocation FinalNoteLoc) {
   1402   int ShownOverloads = 0;
   1403   int SuppressedOverloads = 0;
   1404   for (UnresolvedSetImpl::iterator It = Overloads.begin(),
   1405        DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
   1406     // FIXME: Magic number for max shown overloads stolen from
   1407     // OverloadCandidateSet::NoteCandidates.
   1408     if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
   1409       ++SuppressedOverloads;
   1410       continue;
   1411     }
   1412 
   1413     NamedDecl *Fn = (*It)->getUnderlyingDecl();
   1414     S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
   1415     ++ShownOverloads;
   1416   }
   1417 
   1418   if (SuppressedOverloads)
   1419     S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
   1420       << SuppressedOverloads;
   1421 }
   1422 
   1423 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
   1424                                    const UnresolvedSetImpl &Overloads,
   1425                                    bool (*IsPlausibleResult)(QualType)) {
   1426   if (!IsPlausibleResult)
   1427     return noteOverloads(S, Overloads, Loc);
   1428 
   1429   UnresolvedSet<2> PlausibleOverloads;
   1430   for (OverloadExpr::decls_iterator It = Overloads.begin(),
   1431          DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
   1432     const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
   1433     QualType OverloadResultTy = OverloadDecl->getReturnType();
   1434     if (IsPlausibleResult(OverloadResultTy))
   1435       PlausibleOverloads.addDecl(It.getDecl());
   1436   }
   1437   noteOverloads(S, PlausibleOverloads, Loc);
   1438 }
   1439 
   1440 /// Determine whether the given expression can be called by just
   1441 /// putting parentheses after it.  Notably, expressions with unary
   1442 /// operators can't be because the unary operator will start parsing
   1443 /// outside the call.
   1444 static bool IsCallableWithAppend(Expr *E) {
   1445   E = E->IgnoreImplicit();
   1446   return (!isa<CStyleCastExpr>(E) &&
   1447           !isa<UnaryOperator>(E) &&
   1448           !isa<BinaryOperator>(E) &&
   1449           !isa<CXXOperatorCallExpr>(E));
   1450 }
   1451 
   1452 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
   1453                                 bool ForceComplain,
   1454                                 bool (*IsPlausibleResult)(QualType)) {
   1455   SourceLocation Loc = E.get()->getExprLoc();
   1456   SourceRange Range = E.get()->getSourceRange();
   1457 
   1458   QualType ZeroArgCallTy;
   1459   UnresolvedSet<4> Overloads;
   1460   if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
   1461       !ZeroArgCallTy.isNull() &&
   1462       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
   1463     // At this point, we know E is potentially callable with 0
   1464     // arguments and that it returns something of a reasonable type,
   1465     // so we can emit a fixit and carry on pretending that E was
   1466     // actually a CallExpr.
   1467     SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
   1468     Diag(Loc, PD)
   1469       << /*zero-arg*/ 1 << Range
   1470       << (IsCallableWithAppend(E.get())
   1471           ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
   1472           : FixItHint());
   1473     notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
   1474 
   1475     // FIXME: Try this before emitting the fixit, and suppress diagnostics
   1476     // while doing so.
   1477     E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
   1478                       Range.getEnd().getLocWithOffset(1));
   1479     return true;
   1480   }
   1481 
   1482   if (!ForceComplain) return false;
   1483 
   1484   Diag(Loc, PD) << /*not zero-arg*/ 0 << Range;
   1485   notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
   1486   E = ExprError();
   1487   return true;
   1488 }
   1489 
   1490 IdentifierInfo *Sema::getSuperIdentifier() const {
   1491   if (!Ident_super)
   1492     Ident_super = &Context.Idents.get("super");
   1493   return Ident_super;
   1494 }
   1495 
   1496 IdentifierInfo *Sema::getFloat128Identifier() const {
   1497   if (!Ident___float128)
   1498     Ident___float128 = &Context.Idents.get("__float128");
   1499   return Ident___float128;
   1500 }
   1501 
   1502 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
   1503                                    CapturedRegionKind K) {
   1504   CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
   1505       getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
   1506       (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
   1507   CSI->ReturnType = Context.VoidTy;
   1508   FunctionScopes.push_back(CSI);
   1509 }
   1510 
   1511 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
   1512   if (FunctionScopes.empty())
   1513     return nullptr;
   1514 
   1515   return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
   1516 }
   1517 
   1518 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
   1519 Sema::getMismatchingDeleteExpressions() const {
   1520   return DeleteExprs;
   1521 }
   1522