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

   1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the actions class which performs semantic analysis and
  11 // builds an AST out of a parse stream.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/ASTDiagnostic.h"
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/DeclFriend.h"
  19 #include "clang/AST/DeclObjC.h"
  20 #include "clang/AST/Expr.h"
  21 #include "clang/AST/ExprCXX.h"
  22 #include "clang/AST/PrettyDeclStackTrace.h"
  23 #include "clang/AST/StmtCXX.h"
  24 #include "clang/Basic/DiagnosticOptions.h"
  25 #include "clang/Basic/PartialDiagnostic.h"
  26 #include "clang/Basic/TargetInfo.h"
  27 #include "clang/Lex/HeaderSearch.h"
  28 #include "clang/Lex/Preprocessor.h"
  29 #include "clang/Sema/CXXFieldCollector.h"
  30 #include "clang/Sema/DelayedDiagnostic.h"
  31 #include "clang/Sema/ExternalSemaSource.h"
  32 #include "clang/Sema/Initialization.h"
  33 #include "clang/Sema/MultiplexExternalSemaSource.h"
  34 #include "clang/Sema/ObjCMethodList.h"
  35 #include "clang/Sema/Scope.h"
  36 #include "clang/Sema/ScopeInfo.h"
  37 #include "clang/Sema/SemaConsumer.h"
  38 #include "clang/Sema/SemaInternal.h"
  39 #include "clang/Sema/TemplateDeduction.h"
  40 #include "clang/Sema/TemplateInstCallback.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   // In diagnostics, we print _Bool as bool if the latter is defined as the
  56   // former.
  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 namespace clang {
  75 namespace sema {
  76
  77 class SemaPPCallbacks : public PPCallbacks {
  78   Sema *S = nullptr;
  79   llvm::SmallVector<SourceLocation, 8> IncludeStack;
  80
  81 public:
  82   void set(Sema &S) { this->S = &S; }
  83
  84   void reset() { S = nullptr; }
  85
  86   virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
  87                            SrcMgr::CharacteristicKind FileType,
  88                            FileID PrevFID) override {
  89     if (!S)
  90       return;
  91     switch (Reason) {
  92     case EnterFile: {
  93       SourceManager &SM = S->getSourceManager();
  94       SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
  95       if (IncludeLoc.isValid()) {
  96         IncludeStack.push_back(IncludeLoc);
  97         S->DiagnoseNonDefaultPragmaPack(
  98             Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
  99       }
 100       break;
 101     }
 102     case ExitFile:
 103       if (!IncludeStack.empty())
 104         S->DiagnoseNonDefaultPragmaPack(
 105             Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
 106             IncludeStack.pop_back_val());
 107       break;
 108     default:
 109       break;
 110     }
 111   }
 112 };
 113
 114 } // end namespace sema
 115 } // end namespace clang
 116
 117 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
 118            TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
 119     : ExternalSource(nullptr), isMultiplexExternalSource(false),
 120       FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
 121       Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
 122       SourceMgr(PP.getSourceManager()), CollectStats(false),
 123       CodeCompleter(CodeCompleter), CurContext(nullptr),
 124       OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
 125       MSPointerToMemberRepresentationMethod(
 126           LangOpts.getMSPointerToMemberRepresentationMethod()),
 127       VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
 128       DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
 129       CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
 130       PragmaAttributeCurrentTargetDecl(nullptr),
 131       IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
 132       LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
 133       StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
 134       StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
 135       MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
 136       NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
 137       ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
 138       ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
 139       DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
 140       TUKind(TUKind), NumSFINAEErrors(0),
 141       FullyCheckedComparisonCategories(
 142           static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
 143       AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
 144       NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
 145       CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
 146       TyposCorrected(0), AnalysisWarnings(*this),
 147       ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
 148       CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
 149   TUScope = nullptr;
 150
 151   LoadedExternalKnownNamespaces = false;
 152   for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
 153     NSNumberLiteralMethods[I] = nullptr;
 154
 155   if (getLangOpts().ObjC)
 156     NSAPIObj.reset(new NSAPI(Context));
 157
 158   if (getLangOpts().CPlusPlus)
 159     FieldCollector.reset(new CXXFieldCollector());
 160
 161   // Tell diagnostics how to render things from the AST library.
 162   Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
 163
 164   ExprEvalContexts.emplace_back(
 165       ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
 166       nullptr, ExpressionEvaluationContextRecord::EK_Other);
 167
 168   PreallocatedFunctionScope.reset(new FunctionScopeInfo(Diags));
 169
 170   // Initialization of data sharing attributes stack for OpenMP
 171   InitDataSharingAttributesStack();
 172
 173   std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
 174       llvm::make_unique<sema::SemaPPCallbacks>();
 175   SemaPPCallbackHandler = Callbacks.get();
 176   PP.addPPCallbacks(std::move(Callbacks));
 177   SemaPPCallbackHandler->set(*this);
 178 }
 179
 180 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
 181   DeclarationName DN = &Context.Idents.get(Name);
 182   if (IdResolver.begin(DN) == IdResolver.end())
 183     PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
 184 }
 185
 186 void Sema::Initialize() {
 187   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
 188     SC->InitializeSema(*this);
 189
 190   // Tell the external Sema source about this Sema object.
 191   if (ExternalSemaSource *ExternalSema
 192       = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
 193     ExternalSema->InitializeSema(*this);
 194
 195   // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
 196   // will not be able to merge any duplicate __va_list_tag decls correctly.
 197   VAListTagName = PP.getIdentifierInfo("__va_list_tag");
 198
 199   if (!TUScope)
 200     return;
 201
 202   // Initialize predefined 128-bit integer types, if needed.
 203   if (Context.getTargetInfo().hasInt128Type()) {
 204     // If either of the 128-bit integer types are unavailable to name lookup,
 205     // define them now.
 206     DeclarationName Int128 = &Context.Idents.get("__int128_t");
 207     if (IdResolver.begin(Int128) == IdResolver.end())
 208       PushOnScopeChains(Context.getInt128Decl(), TUScope);
 209
 210     DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
 211     if (IdResolver.begin(UInt128) == IdResolver.end())
 212       PushOnScopeChains(Context.getUInt128Decl(), TUScope);
 213   }
 214
 215
 216   // Initialize predefined Objective-C types:
 217   if (getLangOpts().ObjC) {
 218     // If 'SEL' does not yet refer to any declarations, make it refer to the
 219     // predefined 'SEL'.
 220     DeclarationName SEL = &Context.Idents.get("SEL");
 221     if (IdResolver.begin(SEL) == IdResolver.end())
 222       PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
 223
 224     // If 'id' does not yet refer to any declarations, make it refer to the
 225     // predefined 'id'.
 226     DeclarationName Id = &Context.Idents.get("id");
 227     if (IdResolver.begin(Id) == IdResolver.end())
 228       PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
 229
 230     // Create the built-in typedef for 'Class'.
 231     DeclarationName Class = &Context.Idents.get("Class");
 232     if (IdResolver.begin(Class) == IdResolver.end())
 233       PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
 234
 235     // Create the built-in forward declaratino for 'Protocol'.
 236     DeclarationName Protocol = &Context.Idents.get("Protocol");
 237     if (IdResolver.begin(Protocol) == IdResolver.end())
 238       PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
 239   }
 240
 241   // Create the internal type for the *StringMakeConstantString builtins.
 242   DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
 243   if (IdResolver.begin(ConstantString) == IdResolver.end())
 244     PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
 245
 246   // Initialize Microsoft "predefined C++ types".
 247   if (getLangOpts().MSVCCompat) {
 248     if (getLangOpts().CPlusPlus &&
 249         IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
 250       PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
 251                         TUScope);
 252
 253     addImplicitTypedef("size_t", Context.getSizeType());
 254   }
 255
 256   // Initialize predefined OpenCL types and supported extensions and (optional)
 257   // core features.
 258   if (getLangOpts().OpenCL) {
 259     getOpenCLOptions().addSupport(Context.getTargetInfo().getSupportedOpenCLOpts());
 260     getOpenCLOptions().enableSupportedCore(getLangOpts().OpenCLVersion);
 261     addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
 262     addImplicitTypedef("event_t", Context.OCLEventTy);
 263     if (getLangOpts().OpenCLVersion >= 200) {
 264       addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
 265       addImplicitTypedef("queue_t", Context.OCLQueueTy);
 266       addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
 267       addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
 268       addImplicitTypedef("atomic_uint",
 269                          Context.getAtomicType(Context.UnsignedIntTy));
 270       auto AtomicLongT = Context.getAtomicType(Context.LongTy);
 271       addImplicitTypedef("atomic_long", AtomicLongT);
 272       auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
 273       addImplicitTypedef("atomic_ulong", AtomicULongT);
 274       addImplicitTypedef("atomic_float",
 275                          Context.getAtomicType(Context.FloatTy));
 276       auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
 277       addImplicitTypedef("atomic_double", AtomicDoubleT);
 278       // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
 279       // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
 280       addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
 281       auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
 282       addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
 283       auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
 284       addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
 285       auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
 286       addImplicitTypedef("atomic_size_t", AtomicSizeT);
 287       auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
 288       addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
 289
 290       // OpenCL v2.0 s6.13.11.6:
 291       // - The atomic_long and atomic_ulong types are supported if the
 292       //   cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
 293       //   extensions are supported.
 294       // - The atomic_double type is only supported if double precision
 295       //   is supported and the cl_khr_int64_base_atomics and
 296       //   cl_khr_int64_extended_atomics extensions are supported.
 297       // - If the device address space is 64-bits, the data types
 298       //   atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
 299       //   atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
 300       //   cl_khr_int64_extended_atomics extensions are supported.
 301       std::vector<QualType> Atomic64BitTypes;
 302       Atomic64BitTypes.push_back(AtomicLongT);
 303       Atomic64BitTypes.push_back(AtomicULongT);
 304       Atomic64BitTypes.push_back(AtomicDoubleT);
 305       if (Context.getTypeSize(AtomicSizeT) == 64) {
 306         Atomic64BitTypes.push_back(AtomicSizeT);
 307         Atomic64BitTypes.push_back(AtomicIntPtrT);
 308         Atomic64BitTypes.push_back(AtomicUIntPtrT);
 309         Atomic64BitTypes.push_back(AtomicPtrDiffT);
 310       }
 311       for (auto &I : Atomic64BitTypes)
 312         setOpenCLExtensionForType(I,
 313             "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
 314
 315       setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
 316     }
 317
 318     setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
 319
 320 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
 321     setOpenCLExtensionForType(Context.Id, Ext);
 322 #include "clang/Basic/OpenCLImageTypes.def"
 323 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
 324     addImplicitTypedef(#ExtType, Context.Id##Ty); \
 325     setOpenCLExtensionForType(Context.Id##Ty, #Ext);
 326 #include "clang/Basic/OpenCLExtensionTypes.def"
 327     };
 328
 329   if (Context.getTargetInfo().hasBuiltinMSVaList()) {
 330     DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
 331     if (IdResolver.begin(MSVaList) == IdResolver.end())
 332       PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
 333   }
 334
 335   DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
 336   if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
 337     PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
 338 }
 339
 340 Sema::~Sema() {
 341   if (VisContext) FreeVisContext();
 342
 343   // Kill all the active scopes.
 344   for (sema::FunctionScopeInfo *FSI : FunctionScopes)
 345     if (FSI != PreallocatedFunctionScope.get())
 346       delete FSI;
 347
 348   // Tell the SemaConsumer to forget about us; we're going out of scope.
 349   if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
 350     SC->ForgetSema();
 351
 352   // Detach from the external Sema source.
 353   if (ExternalSemaSource *ExternalSema
 354         = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
 355     ExternalSema->ForgetSema();
 356
 357   // If Sema's ExternalSource is the multiplexer - we own it.
 358   if (isMultiplexExternalSource)
 359     delete ExternalSource;
 360
 361   threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
 362
 363   // Destroys data sharing attributes stack for OpenMP
 364   DestroyDataSharingAttributesStack();
 365
 366   // Detach from the PP callback handler which outlives Sema since it's owned
 367   // by the preprocessor.
 368   SemaPPCallbackHandler->reset();
 369
 370   assert(DelayedTypos.empty() && "Uncorrected typos!");
 371 }
 372
 373 /// makeUnavailableInSystemHeader - There is an error in the current
 374 /// context.  If we're still in a system header, and we can plausibly
 375 /// make the relevant declaration unavailable instead of erroring, do
 376 /// so and return true.
 377 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
 378                                       UnavailableAttr::ImplicitReason reason) {
 379   // If we're not in a function, it's an error.
 380   FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
 381   if (!fn) return false;
 382
 383   // If we're in template instantiation, it's an error.
 384   if (inTemplateInstantiation())
 385     return false;
 386
 387   // If that function's not in a system header, it's an error.
 388   if (!Context.getSourceManager().isInSystemHeader(loc))
 389     return false;
 390
 391   // If the function is already unavailable, it's not an error.
 392   if (fn->hasAttr<UnavailableAttr>()) return true;
 393
 394   fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
 395   return true;
 396 }
 397
 398 ASTMutationListener *Sema::getASTMutationListener() const {
 399   return getASTConsumer().GetASTMutationListener();
 400 }
 401
 402 ///Registers an external source. If an external source already exists,
 403 /// creates a multiplex external source and appends to it.
 404 ///
 405 ///\param[in] E - A non-null external sema source.
 406 ///
 407 void Sema::addExternalSource(ExternalSemaSource *E) {
 408   assert(E && "Cannot use with NULL ptr");
 409
 410   if (!ExternalSource) {
 411     ExternalSource = E;
 412     return;
 413   }
 414
 415   if (isMultiplexExternalSource)
 416     static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
 417   else {
 418     ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
 419     isMultiplexExternalSource = true;
 420   }
 421 }
 422
 423 /// Print out statistics about the semantic analysis.
 424 void Sema::PrintStats() const {
 425   llvm::errs() << "\n*** Semantic Analysis Stats:\n";
 426   llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
 427
 428   BumpAlloc.PrintStats();
 429   AnalysisWarnings.PrintStats();
 430 }
 431
 432 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
 433                                                QualType SrcType,
 434                                                SourceLocation Loc) {
 435   Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
 436   if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
 437     return;
 438
 439   Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
 440   if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
 441     return;
 442
 443   Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
 444 }
 445
 446 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
 447   if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
 448                       E->getBeginLoc()))
 449     return;
 450   // nullptr only exists from C++11 on, so don't warn on its absence earlier.
 451   if (!getLangOpts().CPlusPlus11)
 452     return;
 453
 454   if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
 455     return;
 456   if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
 457     return;
 458
 459   // If it is a macro from system header, and if the macro name is not "NULL",
 460   // do not warn.
 461   SourceLocation MaybeMacroLoc = E->getBeginLoc();
 462   if (Diags.getSuppressSystemWarnings() &&
 463       SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
 464       !findMacroSpelling(MaybeMacroLoc, "NULL"))
 465     return;
 466
 467   Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
 468       << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
 469 }
 470
 471 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
 472 /// If there is already an implicit cast, merge into the existing one.
 473 /// The result is of the given category.
 474 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
 475                                    CastKind Kind, ExprValueKind VK,
 476                                    const CXXCastPath *BasePath,
 477                                    CheckedConversionKind CCK) {
 478 #ifndef NDEBUG
 479   if (VK == VK_RValue && !E->isRValue()) {
 480     switch (Kind) {
 481     default:
 482       llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
 483                        "kind");
 484     case CK_LValueToRValue:
 485     case CK_ArrayToPointerDecay:
 486     case CK_FunctionToPointerDecay:
 487     case CK_ToVoid:
 488     case CK_NonAtomicToAtomic:
 489       break;
 490     }
 491   }
 492   assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
 493 #endif
 494
 495   diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
 496   diagnoseZeroToNullptrConversion(Kind, E);
 497
 498   QualType ExprTy = Context.getCanonicalType(E->getType());
 499   QualType TypeTy = Context.getCanonicalType(Ty);
 500
 501   if (ExprTy == TypeTy)
 502     return E;
 503
 504   // C++1z [conv.array]: The temporary materialization conversion is applied.
 505   // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
 506   if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
 507       E->getValueKind() == VK_RValue) {
 508     // The temporary is an lvalue in C++98 and an xvalue otherwise.
 509     ExprResult Materialized = CreateMaterializeTemporaryExpr(
 510         E->getType(), E, !getLangOpts().CPlusPlus11);
 511     if (Materialized.isInvalid())
 512       return ExprError();
 513     E = Materialized.get();
 514   }
 515
 516   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
 517     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
 518       ImpCast->setType(Ty);
 519       ImpCast->setValueKind(VK);
 520       return E;
 521     }
 522   }
 523
 524   return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
 525 }
 526
 527 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
 528 /// to the conversion from scalar type ScalarTy to the Boolean type.
 529 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
 530   switch (ScalarTy->getScalarTypeKind()) {
 531   case Type::STK_Bool: return CK_NoOp;
 532   case Type::STK_CPointer: return CK_PointerToBoolean;
 533   case Type::STK_BlockPointer: return CK_PointerToBoolean;
 534   case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
 535   case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
 536   case Type::STK_Integral: return CK_IntegralToBoolean;
 537   case Type::STK_Floating: return CK_FloatingToBoolean;
 538   case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
 539   case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
 540   case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
 541   }
 542   llvm_unreachable("unknown scalar type kind");
 543 }
 544
 545 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
 546 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
 547   if (D->getMostRecentDecl()->isUsed())
 548     return true;
 549
 550   if (D->isExternallyVisible())
 551     return true;
 552
 553   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 554     // If this is a function template and none of its specializations is used,
 555     // we should warn.
 556     if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
 557       for (const auto *Spec : Template->specializations())
 558         if (ShouldRemoveFromUnused(SemaRef, Spec))
 559           return true;
 560
 561     // UnusedFileScopedDecls stores the first declaration.
 562     // The declaration may have become definition so check again.
 563     const FunctionDecl *DeclToCheck;
 564     if (FD->hasBody(DeclToCheck))
 565       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 566
 567     // Later redecls may add new information resulting in not having to warn,
 568     // so check again.
 569     DeclToCheck = FD->getMostRecentDecl();
 570     if (DeclToCheck != FD)
 571       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 572   }
 573
 574   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
 575     // If a variable usable in constant expressions is referenced,
 576     // don't warn if it isn't used: if the value of a variable is required
 577     // for the computation of a constant expression, it doesn't make sense to
 578     // warn even if the variable isn't odr-used.  (isReferenced doesn't
 579     // precisely reflect that, but it's a decent approximation.)
 580     if (VD->isReferenced() &&
 581         VD->isUsableInConstantExpressions(SemaRef->Context))
 582       return true;
 583
 584     if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
 585       // If this is a variable template and none of its specializations is used,
 586       // we should warn.
 587       for (const auto *Spec : Template->specializations())
 588         if (ShouldRemoveFromUnused(SemaRef, Spec))
 589           return true;
 590
 591     // UnusedFileScopedDecls stores the first declaration.
 592     // The declaration may have become definition so check again.
 593     const VarDecl *DeclToCheck = VD->getDefinition();
 594     if (DeclToCheck)
 595       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 596
 597     // Later redecls may add new information resulting in not having to warn,
 598     // so check again.
 599     DeclToCheck = VD->getMostRecentDecl();
 600     if (DeclToCheck != VD)
 601       return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
 602   }
 603
 604   return false;
 605 }
 606
 607 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
 608   if (auto *FD = dyn_cast<FunctionDecl>(ND))
 609     return FD->isExternC();
 610   return cast<VarDecl>(ND)->isExternC();
 611 }
 612
 613 /// Determine whether ND is an external-linkage function or variable whose
 614 /// type has no linkage.
 615 bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
 616   // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
 617   // because we also want to catch the case where its type has VisibleNoLinkage,
 618   // which does not affect the linkage of VD.
 619   return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
 620          !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
 621          !isFunctionOrVarDeclExternC(VD);
 622 }
 623
 624 /// Obtains a sorted list of functions and variables that are undefined but
 625 /// ODR-used.
 626 void Sema::getUndefinedButUsed(
 627     SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
 628   for (const auto &UndefinedUse : UndefinedButUsed) {
 629     NamedDecl *ND = UndefinedUse.first;
 630
 631     // Ignore attributes that have become invalid.
 632     if (ND->isInvalidDecl()) continue;
 633
 634     // __attribute__((weakref)) is basically a definition.
 635     if (ND->hasAttr<WeakRefAttr>()) continue;
 636
 637     if (isa<CXXDeductionGuideDecl>(ND))
 638       continue;
 639
 640     if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
 641       // An exported function will always be emitted when defined, so even if
 642       // the function is inline, it doesn't have to be emitted in this TU. An
 643       // imported function implies that it has been exported somewhere else.
 644       continue;
 645     }
 646
 647     if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
 648       if (FD->isDefined())
 649         continue;
 650       if (FD->isExternallyVisible() &&
 651           !isExternalWithNoLinkageType(FD) &&
 652           !FD->getMostRecentDecl()->isInlined() &&
 653           !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
 654         continue;
 655       if (FD->getBuiltinID())
 656         continue;
 657     } else {
 658       auto *VD = cast<VarDecl>(ND);
 659       if (VD->hasDefinition() != VarDecl::DeclarationOnly)
 660         continue;
 661       if (VD->isExternallyVisible() &&
 662           !isExternalWithNoLinkageType(VD) &&
 663           !VD->getMostRecentDecl()->isInline() &&
 664           !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
 665         continue;
 666
 667       // Skip VarDecls that lack formal definitions but which we know are in
 668       // fact defined somewhere.
 669       if (VD->isKnownToBeDefined())
 670         continue;
 671     }
 672
 673     Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
 674   }
 675 }
 676
 677 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
 678 /// or that are inline.
 679 static void checkUndefinedButUsed(Sema &S) {
 680   if (S.UndefinedButUsed.empty()) return;
 681
 682   // Collect all the still-undefined entities with internal linkage.
 683   SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
 684   S.getUndefinedButUsed(Undefined);
 685   if (Undefined.empty()) return;
 686
 687   for (auto Undef : Undefined) {
 688     ValueDecl *VD = cast<ValueDecl>(Undef.first);
 689     SourceLocation UseLoc = Undef.second;
 690
 691     if (S.isExternalWithNoLinkageType(VD)) {
 692       // C++ [basic.link]p8:
 693       //   A type without linkage shall not be used as the type of a variable
 694       //   or function with external linkage unless
 695       //    -- the entity has C language linkage
 696       //    -- the entity is not odr-used or is defined in the same TU
 697       //
 698       // As an extension, accept this in cases where the type is externally
 699       // visible, since the function or variable actually can be defined in
 700       // another translation unit in that case.
 701       S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
 702                                     ? diag::ext_undefined_internal_type
 703                                     : diag::err_undefined_internal_type)
 704         << isa<VarDecl>(VD) << VD;
 705     } else if (!VD->isExternallyVisible()) {
 706       // FIXME: We can promote this to an error. The function or variable can't
 707       // be defined anywhere else, so the program must necessarily violate the
 708       // one definition rule.
 709       S.Diag(VD->getLocation(), diag::warn_undefined_internal)
 710         << isa<VarDecl>(VD) << VD;
 711     } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
 712       (void)FD;
 713       assert(FD->getMostRecentDecl()->isInlined() &&
 714              "used object requires definition but isn't inline or internal?");
 715       // FIXME: This is ill-formed; we should reject.
 716       S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
 717     } else {
 718       assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
 719              "used var requires definition but isn't inline or internal?");
 720       S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
 721     }
 722     if (UseLoc.isValid())
 723       S.Diag(UseLoc, diag::note_used_here);
 724   }
 725
 726   S.UndefinedButUsed.clear();
 727 }
 728
 729 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
 730   if (!ExternalSource)
 731     return;
 732
 733   SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
 734   ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
 735   for (auto &WeakID : WeakIDs)
 736     WeakUndeclaredIdentifiers.insert(WeakID);
 737 }
 738
 739
 740 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
 741
 742 /// Returns true, if all methods and nested classes of the given
 743 /// CXXRecordDecl are defined in this translation unit.
 744 ///
 745 /// Should only be called from ActOnEndOfTranslationUnit so that all
 746 /// definitions are actually read.
 747 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
 748                                             RecordCompleteMap &MNCComplete) {
 749   RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
 750   if (Cache != MNCComplete.end())
 751     return Cache->second;
 752   if (!RD->isCompleteDefinition())
 753     return false;
 754   bool Complete = true;
 755   for (DeclContext::decl_iterator I = RD->decls_begin(),
 756                                   E = RD->decls_end();
 757        I != E && Complete; ++I) {
 758     if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
 759       Complete = M->isDefined() || M->isDefaulted() ||
 760                  (M->isPure() && !isa<CXXDestructorDecl>(M));
 761     else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
 762       // If the template function is marked as late template parsed at this
 763       // point, it has not been instantiated and therefore we have not
 764       // performed semantic analysis on it yet, so we cannot know if the type
 765       // can be considered complete.
 766       Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
 767                   F->getTemplatedDecl()->isDefined();
 768     else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
 769       if (R->isInjectedClassName())
 770         continue;
 771       if (R->hasDefinition())
 772         Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
 773                                                    MNCComplete);
 774       else
 775         Complete = false;
 776     }
 777   }
 778   MNCComplete[RD] = Complete;
 779   return Complete;
 780 }
 781
 782 /// Returns true, if the given CXXRecordDecl is fully defined in this
 783 /// translation unit, i.e. all methods are defined or pure virtual and all
 784 /// friends, friend functions and nested classes are fully defined in this
 785 /// translation unit.
 786 ///
 787 /// Should only be called from ActOnEndOfTranslationUnit so that all
 788 /// definitions are actually read.
 789 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
 790                                  RecordCompleteMap &RecordsComplete,
 791                                  RecordCompleteMap &MNCComplete) {
 792   RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
 793   if (Cache != RecordsComplete.end())
 794     return Cache->second;
 795   bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
 796   for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
 797                                       E = RD->friend_end();
 798        I != E && Complete; ++I) {
 799     // Check if friend classes and methods are complete.
 800     if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
 801       // Friend classes are available as the TypeSourceInfo of the FriendDecl.
 802       if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
 803         Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
 804       else
 805         Complete = false;
 806     } else {
 807       // Friend functions are available through the NamedDecl of FriendDecl.
 808       if (const FunctionDecl *FD =
 809           dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
 810         Complete = FD->isDefined();
 811       else
 812         // This is a template friend, give up.
 813         Complete = false;
 814     }
 815   }
 816   RecordsComplete[RD] = Complete;
 817   return Complete;
 818 }
 819
 820 void Sema::emitAndClearUnusedLocalTypedefWarnings() {
 821   if (ExternalSource)
 822     ExternalSource->ReadUnusedLocalTypedefNameCandidates(
 823         UnusedLocalTypedefNameCandidates);
 824   for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
 825     if (TD->isReferenced())
 826       continue;
 827     Diag(TD->getLocation(), diag::warn_unused_local_typedef)
 828         << isa<TypeAliasDecl>(TD) << TD->getDeclName();
 829   }
 830   UnusedLocalTypedefNameCandidates.clear();
 831 }
 832
 833 /// This is called before the very first declaration in the translation unit
 834 /// is parsed. Note that the ASTContext may have already injected some
 835 /// declarations.
 836 void Sema::ActOnStartOfTranslationUnit() {
 837   if (getLangOpts().ModulesTS &&
 838       (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
 839        getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
 840     SourceLocation StartOfTU =
 841         SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
 842
 843     // We start in the global module; all those declarations are implicitly
 844     // module-private (though they do not have module linkage).
 845     auto &Map = PP.getHeaderSearchInfo().getModuleMap();
 846     auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU);
 847     assert(GlobalModule && "module creation should not fail");
 848
 849     // Enter the scope of the global module.
 850     ModuleScopes.push_back({});
 851     ModuleScopes.back().Module = GlobalModule;
 852     VisibleModules.setVisible(GlobalModule, StartOfTU);
 853
 854     // All declarations created from now on are owned by the global module.
 855     auto *TU = Context.getTranslationUnitDecl();
 856     TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
 857     TU->setLocalOwningModule(GlobalModule);
 858   }
 859 }
 860
 861 /// ActOnEndOfTranslationUnit - This is called at the very end of the
 862 /// translation unit when EOF is reached and all but the top-level scope is
 863 /// popped.
 864 void Sema::ActOnEndOfTranslationUnit() {
 865   assert(DelayedDiagnostics.getCurrentPool() == nullptr
 866          && "reached end of translation unit with a pool attached?");
 867
 868   // If code completion is enabled, don't perform any end-of-translation-unit
 869   // work.
 870   if (PP.isCodeCompletionEnabled())
 871     return;
 872
 873   // Transfer late parsed template instantiations over to the pending template
 874   // instantiation list. During normal compliation, the late template parser
 875   // will be installed and instantiating these templates will succeed.
 876   //
 877   // If we are building a TU prefix for serialization, it is also safe to
 878   // transfer these over, even though they are not parsed. The end of the TU
 879   // should be outside of any eager template instantiation scope, so when this
 880   // AST is deserialized, these templates will not be parsed until the end of
 881   // the combined TU.
 882   PendingInstantiations.insert(PendingInstantiations.end(),
 883                                LateParsedInstantiations.begin(),
 884                                LateParsedInstantiations.end());
 885   LateParsedInstantiations.clear();
 886
 887   // Complete translation units and modules define vtables and perform implicit
 888   // instantiations. PCH files do not.
 889   if (TUKind != TU_Prefix) {
 890     DiagnoseUseOfUnimplementedSelectors();
 891
 892     // If DefinedUsedVTables ends up marking any virtual member functions it
 893     // might lead to more pending template instantiations, which we then need
 894     // to instantiate.
 895     DefineUsedVTables();
 896
 897     // C++: Perform implicit template instantiations.
 898     //
 899     // FIXME: When we perform these implicit instantiations, we do not
 900     // carefully keep track of the point of instantiation (C++ [temp.point]).
 901     // This means that name lookup that occurs within the template
 902     // instantiation will always happen at the end of the translation unit,
 903     // so it will find some names that are not required to be found. This is
 904     // valid, but we could do better by diagnosing if an instantiation uses a
 905     // name that was not visible at its first point of instantiation.
 906     if (ExternalSource) {
 907       // Load pending instantiations from the external source.
 908       SmallVector<PendingImplicitInstantiation, 4> Pending;
 909       ExternalSource->ReadPendingInstantiations(Pending);
 910       for (auto PII : Pending)
 911         if (auto Func = dyn_cast<FunctionDecl>(PII.first))
 912           Func->setInstantiationIsPending(true);
 913       PendingInstantiations.insert(PendingInstantiations.begin(),
 914                                    Pending.begin(), Pending.end());
 915     }
 916
 917     PerformPendingInstantiations();
 918
 919     assert(LateParsedInstantiations.empty() &&
 920            "end of TU template instantiation should not create more "
 921            "late-parsed templates");
 922
 923     if (LateTemplateParserCleanup)
 924       LateTemplateParserCleanup(OpaqueParser);
 925
 926     CheckDelayedMemberExceptionSpecs();
 927   }
 928
 929   DiagnoseUnterminatedPragmaPack();
 930   DiagnoseUnterminatedPragmaAttribute();
 931
 932   // All delayed member exception specs should be checked or we end up accepting
 933   // incompatible declarations.
 934   assert(DelayedOverridingExceptionSpecChecks.empty());
 935   assert(DelayedEquivalentExceptionSpecChecks.empty());
 936   assert(DelayedDefaultedMemberExceptionSpecs.empty());
 937
 938   // All dllexport classes should have been processed already.
 939   assert(DelayedDllExportClasses.empty());
 940
 941   // Remove file scoped decls that turned out to be used.
 942   UnusedFileScopedDecls.erase(
 943       std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
 944                      UnusedFileScopedDecls.end(),
 945                      [this](const DeclaratorDecl *DD) {
 946                        return ShouldRemoveFromUnused(this, DD);
 947                      }),
 948       UnusedFileScopedDecls.end());
 949
 950   if (TUKind == TU_Prefix) {
 951     // Translation unit prefixes don't need any of the checking below.
 952     if (!PP.isIncrementalProcessingEnabled())
 953       TUScope = nullptr;
 954     return;
 955   }
 956
 957   // Check for #pragma weak identifiers that were never declared
 958   LoadExternalWeakUndeclaredIdentifiers();
 959   for (auto WeakID : WeakUndeclaredIdentifiers) {
 960     if (WeakID.second.getUsed())
 961       continue;
 962
 963     Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
 964                                       LookupOrdinaryName);
 965     if (PrevDecl != nullptr &&
 966         !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
 967       Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
 968           << "'weak'" << ExpectedVariableOrFunction;
 969     else
 970       Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
 971           << WeakID.first;
 972   }
 973
 974   if (LangOpts.CPlusPlus11 &&
 975       !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
 976     CheckDelegatingCtorCycles();
 977
 978   if (!Diags.hasErrorOccurred()) {
 979     if (ExternalSource)
 980       ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
 981     checkUndefinedButUsed(*this);
 982   }
 983
 984   if (TUKind == TU_Module) {
 985     // If we are building a module interface unit, we need to have seen the
 986     // module declaration by now.
 987     if (getLangOpts().getCompilingModule() ==
 988             LangOptions::CMK_ModuleInterface &&
 989         (ModuleScopes.empty() ||
 990          ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit)) {
 991       // FIXME: Make a better guess as to where to put the module declaration.
 992       Diag(getSourceManager().getLocForStartOfFile(
 993                getSourceManager().getMainFileID()),
 994            diag::err_module_declaration_missing);
 995     }
 996
 997     // If we are building a module, resolve all of the exported declarations
 998     // now.
 999     if (Module *CurrentModule = PP.getCurrentModule()) {
1000       ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
1001
1002       SmallVector<Module *, 2> Stack;
1003       Stack.push_back(CurrentModule);
1004       while (!Stack.empty()) {
1005         Module *Mod = Stack.pop_back_val();
1006
1007         // Resolve the exported declarations and conflicts.
1008         // FIXME: Actually complain, once we figure out how to teach the
1009         // diagnostic client to deal with complaints in the module map at this
1010         // point.
1011         ModMap.resolveExports(Mod, /*Complain=*/false);
1012         ModMap.resolveUses(Mod, /*Complain=*/false);
1013         ModMap.resolveConflicts(Mod, /*Complain=*/false);
1014
1015         // Queue the submodules, so their exports will also be resolved.
1016         Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1017       }
1018     }
1019
1020     // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1021     // modules when they are built, not every time they are used.
1022     emitAndClearUnusedLocalTypedefWarnings();
1023   }
1024
1025   // C99 6.9.2p2:
1026   //   A declaration of an identifier for an object that has file
1027   //   scope without an initializer, and without a storage-class
1028   //   specifier or with the storage-class specifier static,
1029   //   constitutes a tentative definition. If a translation unit
1030   //   contains one or more tentative definitions for an identifier,
1031   //   and the translation unit contains no external definition for
1032   //   that identifier, then the behavior is exactly as if the
1033   //   translation unit contains a file scope declaration of that
1034   //   identifier, with the composite type as of the end of the
1035   //   translation unit, with an initializer equal to 0.
1036   llvm::SmallSet<VarDecl *, 32> Seen;
1037   for (TentativeDefinitionsType::iterator
1038             T = TentativeDefinitions.begin(ExternalSource),
1039          TEnd = TentativeDefinitions.end();
1040        T != TEnd; ++T) {
1041     VarDecl *VD = (*T)->getActingDefinition();
1042
1043     // If the tentative definition was completed, getActingDefinition() returns
1044     // null. If we've already seen this variable before, insert()'s second
1045     // return value is false.
1046     if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1047       continue;
1048
1049     if (const IncompleteArrayType *ArrayT
1050         = Context.getAsIncompleteArrayType(VD->getType())) {
1051       // Set the length of the array to 1 (C99 6.9.2p5).
1052       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1053       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1054       QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1055                                                 One, ArrayType::Normal, 0);
1056       VD->setType(T);
1057     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1058                                    diag::err_tentative_def_incomplete_type))
1059       VD->setInvalidDecl();
1060
1061     // No initialization is performed for a tentative definition.
1062     CheckCompleteVariableDeclaration(VD);
1063
1064     // Notify the consumer that we've completed a tentative definition.
1065     if (!VD->isInvalidDecl())
1066       Consumer.CompleteTentativeDefinition(VD);
1067   }
1068
1069   // If there were errors, disable 'unused' warnings since they will mostly be
1070   // noise. Don't warn for a use from a module: either we should warn on all
1071   // file-scope declarations in modules or not at all, but whether the
1072   // declaration is used is immaterial.
1073   if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1074     // Output warning for unused file scoped decls.
1075     for (UnusedFileScopedDeclsType::iterator
1076            I = UnusedFileScopedDecls.begin(ExternalSource),
1077            E = UnusedFileScopedDecls.end(); I != E; ++I) {
1078       if (ShouldRemoveFromUnused(this, *I))
1079         continue;
1080
1081       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1082         const FunctionDecl *DiagD;
1083         if (!FD->hasBody(DiagD))
1084           DiagD = FD;
1085         if (DiagD->isDeleted())
1086           continue; // Deleted functions are supposed to be unused.
1087         if (DiagD->isReferenced()) {
1088           if (isa<CXXMethodDecl>(DiagD))
1089             Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1090                   << DiagD->getDeclName();
1091           else {
1092             if (FD->getStorageClass() == SC_Static &&
1093                 !FD->isInlineSpecified() &&
1094                 !SourceMgr.isInMainFile(
1095                    SourceMgr.getExpansionLoc(FD->getLocation())))
1096               Diag(DiagD->getLocation(),
1097                    diag::warn_unneeded_static_internal_decl)
1098                   << DiagD->getDeclName();
1099             else
1100               Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1101                    << /*function*/0 << DiagD->getDeclName();
1102           }
1103         } else {
1104           if (FD->getDescribedFunctionTemplate())
1105             Diag(DiagD->getLocation(), diag::warn_unused_template)
1106               << /*function*/0 << DiagD->getDeclName();
1107           else
1108             Diag(DiagD->getLocation(),
1109                  isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1110                                            : diag::warn_unused_function)
1111               << DiagD->getDeclName();
1112         }
1113       } else {
1114         const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1115         if (!DiagD)
1116           DiagD = cast<VarDecl>(*I);
1117         if (DiagD->isReferenced()) {
1118           Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1119                 << /*variable*/1 << DiagD->getDeclName();
1120         } else if (DiagD->getType().isConstQualified()) {
1121           const SourceManager &SM = SourceMgr;
1122           if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1123               !PP.getLangOpts().IsHeaderFile)
1124             Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1125                 << DiagD->getDeclName();
1126         } else {
1127           if (DiagD->getDescribedVarTemplate())
1128             Diag(DiagD->getLocation(), diag::warn_unused_template)
1129               << /*variable*/1 << DiagD->getDeclName();
1130           else
1131             Diag(DiagD->getLocation(), diag::warn_unused_variable)
1132               << DiagD->getDeclName();
1133         }
1134       }
1135     }
1136
1137     emitAndClearUnusedLocalTypedefWarnings();
1138   }
1139
1140   if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1141     // FIXME: Load additional unused private field candidates from the external
1142     // source.
1143     RecordCompleteMap RecordsComplete;
1144     RecordCompleteMap MNCComplete;
1145     for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1146          E = UnusedPrivateFields.end(); I != E; ++I) {
1147       const NamedDecl *D = *I;
1148       const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1149       if (RD && !RD->isUnion() &&
1150           IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1151         Diag(D->getLocation(), diag::warn_unused_private_field)
1152               << D->getDeclName();
1153       }
1154     }
1155   }
1156
1157   if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1158     if (ExternalSource)
1159       ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1160     for (const auto &DeletedFieldInfo : DeleteExprs) {
1161       for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1162         AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1163                                   DeleteExprLoc.second);
1164       }
1165     }
1166   }
1167
1168   // Check we've noticed that we're no longer parsing the initializer for every
1169   // variable. If we miss cases, then at best we have a performance issue and
1170   // at worst a rejects-valid bug.
1171   assert(ParsingInitForAutoVars.empty() &&
1172          "Didn't unmark var as having its initializer parsed");
1173
1174   if (!PP.isIncrementalProcessingEnabled())
1175     TUScope = nullptr;
1176 }
1177
1178
1179 //===----------------------------------------------------------------------===//
1180 // Helper functions.
1181 //===----------------------------------------------------------------------===//
1182
1183 DeclContext *Sema::getFunctionLevelDeclContext() {
1184   DeclContext *DC = CurContext;
1185
1186   while (true) {
1187     if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1188       DC = DC->getParent();
1189     } else if (isa<CXXMethodDecl>(DC) &&
1190                cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1191                cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1192       DC = DC->getParent()->getParent();
1193     }
1194     else break;
1195   }
1196
1197   return DC;
1198 }
1199
1200 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1201 /// to the function decl for the function being parsed.  If we're currently
1202 /// in a 'block', this returns the containing context.
1203 FunctionDecl *Sema::getCurFunctionDecl() {
1204   DeclContext *DC = getFunctionLevelDeclContext();
1205   return dyn_cast<FunctionDecl>(DC);
1206 }
1207
1208 ObjCMethodDecl *Sema::getCurMethodDecl() {
1209   DeclContext *DC = getFunctionLevelDeclContext();
1210   while (isa<RecordDecl>(DC))
1211     DC = DC->getParent();
1212   return dyn_cast<ObjCMethodDecl>(DC);
1213 }
1214
1215 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
1216   DeclContext *DC = getFunctionLevelDeclContext();
1217   if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1218     return cast<NamedDecl>(DC);
1219   return nullptr;
1220 }
1221
1222 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1223   // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1224   // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1225   // been made more painfully obvious by the refactor that introduced this
1226   // function, but it is possible that the incoming argument can be
1227   // eliminated. If it truly cannot be (for example, there is some reentrancy
1228   // issue I am not seeing yet), then there should at least be a clarifying
1229   // comment somewhere.
1230   if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
1231     switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1232               Diags.getCurrentDiagID())) {
1233     case DiagnosticIDs::SFINAE_Report:
1234       // We'll report the diagnostic below.
1235       break;
1236
1237     case DiagnosticIDs::SFINAE_SubstitutionFailure:
1238       // Count this failure so that we know that template argument deduction
1239       // has failed.
1240       ++NumSFINAEErrors;
1241
1242       // Make a copy of this suppressed diagnostic and store it with the
1243       // template-deduction information.
1244       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1245         Diagnostic DiagInfo(&Diags);
1246         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1247                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1248       }
1249
1250       Diags.setLastDiagnosticIgnored();
1251       Diags.Clear();
1252       return;
1253
1254     case DiagnosticIDs::SFINAE_AccessControl: {
1255       // Per C++ Core Issue 1170, access control is part of SFINAE.
1256       // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1257       // make access control a part of SFINAE for the purposes of checking
1258       // type traits.
1259       if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
1260         break;
1261
1262       SourceLocation Loc = Diags.getCurrentDiagLoc();
1263
1264       // Suppress this diagnostic.
1265       ++NumSFINAEErrors;
1266
1267       // Make a copy of this suppressed diagnostic and store it with the
1268       // template-deduction information.
1269       if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1270         Diagnostic DiagInfo(&Diags);
1271         (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1272                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1273       }
1274
1275       Diags.setLastDiagnosticIgnored();
1276       Diags.Clear();
1277
1278       // Now the diagnostic state is clear, produce a C++98 compatibility
1279       // warning.
1280       Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1281
1282       // The last diagnostic which Sema produced was ignored. Suppress any
1283       // notes attached to it.
1284       Diags.setLastDiagnosticIgnored();
1285       return;
1286     }
1287
1288     case DiagnosticIDs::SFINAE_Suppress:
1289       // Make a copy of this suppressed diagnostic and store it with the
1290       // template-deduction information;
1291       if (*Info) {
1292         Diagnostic DiagInfo(&Diags);
1293         (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1294                        PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1295       }
1296
1297       // Suppress this diagnostic.
1298       Diags.setLastDiagnosticIgnored();
1299       Diags.Clear();
1300       return;
1301     }
1302   }
1303
1304   // Copy the diagnostic printing policy over the ASTContext printing policy.
1305   // TODO: Stop doing that.  See: https://reviews.llvm.org/D45093#1090292
1306   Context.setPrintingPolicy(getPrintingPolicy());
1307
1308   // Emit the diagnostic.
1309   if (!Diags.EmitCurrentDiagnostic())
1310     return;
1311
1312   // If this is not a note, and we're in a template instantiation
1313   // that is different from the last template instantiation where
1314   // we emitted an error, print a template instantiation
1315   // backtrace.
1316   if (!DiagnosticIDs::isBuiltinNote(DiagID))
1317     PrintContextStack();
1318 }
1319
1320 Sema::SemaDiagnosticBuilder
1321 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1322   SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1323   PD.Emit(Builder);
1324
1325   return Builder;
1326 }
1327
1328 /// Looks through the macro-expansion chain for the given
1329 /// location, looking for a macro expansion with the given name.
1330 /// If one is found, returns true and sets the location to that
1331 /// expansion loc.
1332 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1333   SourceLocation loc = locref;
1334   if (!loc.isMacroID()) return false;
1335
1336   // There's no good way right now to look at the intermediate
1337   // expansions, so just jump to the expansion location.
1338   loc = getSourceManager().getExpansionLoc(loc);
1339
1340   // If that's written with the name, stop here.
1341   SmallVector<char, 16> buffer;
1342   if (getPreprocessor().getSpelling(loc, buffer) == name) {
1343     locref = loc;
1344     return true;
1345   }
1346   return false;
1347 }
1348
1349 /// Determines the active Scope associated with the given declaration
1350 /// context.
1351 ///
1352 /// This routine maps a declaration context to the active Scope object that
1353 /// represents that declaration context in the parser. It is typically used
1354 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1355 /// declarations) that injects a name for name-lookup purposes and, therefore,
1356 /// must update the Scope.
1357 ///
1358 /// \returns The scope corresponding to the given declaraion context, or NULL
1359 /// if no such scope is open.
1360 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
1361
1362   if (!Ctx)
1363     return nullptr;
1364
1365   Ctx = Ctx->getPrimaryContext();
1366   for (Scope *S = getCurScope(); S; S = S->getParent()) {
1367     // Ignore scopes that cannot have declarations. This is important for
1368     // out-of-line definitions of static class members.
1369     if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1370       if (DeclContext *Entity = S->getEntity())
1371         if (Ctx == Entity->getPrimaryContext())
1372           return S;
1373   }
1374
1375   return nullptr;
1376 }
1377
1378 /// Enter a new function scope
1379 void Sema::PushFunctionScope() {
1380   if (FunctionScopes.empty()) {
1381     // Use PreallocatedFunctionScope to avoid allocating memory when possible.
1382     PreallocatedFunctionScope->Clear();
1383     FunctionScopes.push_back(PreallocatedFunctionScope.get());
1384   } else {
1385     FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1386   }
1387   if (LangOpts.OpenMP)
1388     pushOpenMPFunctionRegion();
1389 }
1390
1391 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1392   FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1393                                               BlockScope, Block));
1394 }
1395
1396 LambdaScopeInfo *Sema::PushLambdaScope() {
1397   LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1398   FunctionScopes.push_back(LSI);
1399   return LSI;
1400 }
1401
1402 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1403   if (LambdaScopeInfo *const LSI = getCurLambda()) {
1404     LSI->AutoTemplateParameterDepth = Depth;
1405     return;
1406   }
1407   llvm_unreachable(
1408       "Remove assertion if intentionally called in a non-lambda context.");
1409 }
1410
1411 // Check that the type of the VarDecl has an accessible copy constructor and
1412 // resolve its destructor's exception spefication.
1413 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1414   QualType T = VD->getType();
1415   EnterExpressionEvaluationContext scope(
1416       S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1417   SourceLocation Loc = VD->getLocation();
1418   Expr *VarRef =
1419       new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1420   ExprResult Result = S.PerformMoveOrCopyInitialization(
1421       InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1422       VarRef, /*AllowNRVO=*/true);
1423   if (!Result.isInvalid()) {
1424     Result = S.MaybeCreateExprWithCleanups(Result);
1425     Expr *Init = Result.getAs<Expr>();
1426     S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1427   }
1428
1429   // The destructor's exception spefication is needed when IRGen generates
1430   // block copy/destroy functions. Resolve it here.
1431   if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1432     if (CXXDestructorDecl *DD = RD->getDestructor()) {
1433       auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1434       S.ResolveExceptionSpec(Loc, FPT);
1435     }
1436 }
1437
1438 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1439   // Set the EscapingByref flag of __block variables captured by
1440   // escaping blocks.
1441   for (const BlockDecl *BD : FSI.Blocks) {
1442     if (BD->doesNotEscape())
1443       continue;
1444     for (const BlockDecl::Capture &BC : BD->captures()) {
1445       VarDecl *VD = BC.getVariable();
1446       if (VD->hasAttr<BlocksAttr>())
1447         VD->setEscapingByref();
1448     }
1449   }
1450
1451   for (VarDecl *VD : FSI.ByrefBlockVars) {
1452     // __block variables might require us to capture a copy-initializer.
1453     if (!VD->isEscapingByref())
1454       continue;
1455     // It's currently invalid to ever have a __block variable with an
1456     // array type; should we diagnose that here?
1457     // Regardless, we don't want to ignore array nesting when
1458     // constructing this copy.
1459     if (VD->getType()->isStructureOrClassType())
1460       checkEscapingByref(VD, S);
1461   }
1462 }
1463
1464 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1465                                 const Decl *D, const BlockExpr *blkExpr) {
1466   assert(!FunctionScopes.empty() && "mismatched push/pop!");
1467
1468   // This function shouldn't be called after popping the current function scope.
1469   // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1470   // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1471   // when FunctionScopes is empty.
1472   markEscapingByrefs(*FunctionScopes.back(), *this);
1473
1474   FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1475
1476   if (LangOpts.OpenMP)
1477     popOpenMPFunctionRegion(Scope);
1478
1479   // Issue any analysis-based warnings.
1480   if (WP && D)
1481     AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1482   else
1483     for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1484       Diag(PUD.Loc, PUD.PD);
1485
1486   // Delete the scope unless its our preallocated scope.
1487   if (Scope != PreallocatedFunctionScope.get())
1488     delete Scope;
1489 }
1490
1491 void Sema::PushCompoundScope(bool IsStmtExpr) {
1492   getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1493 }
1494
1495 void Sema::PopCompoundScope() {
1496   FunctionScopeInfo *CurFunction = getCurFunction();
1497   assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1498
1499   CurFunction->CompoundScopes.pop_back();
1500 }
1501
1502 /// Determine whether any errors occurred within this function/method/
1503 /// block.
1504 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1505   return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1506 }
1507
1508 void Sema::setFunctionHasBranchIntoScope() {
1509   if (!FunctionScopes.empty())
1510     FunctionScopes.back()->setHasBranchIntoScope();
1511 }
1512
1513 void Sema::setFunctionHasBranchProtectedScope() {
1514   if (!FunctionScopes.empty())
1515     FunctionScopes.back()->setHasBranchProtectedScope();
1516 }
1517
1518 void Sema::setFunctionHasIndirectGoto() {
1519   if (!FunctionScopes.empty())
1520     FunctionScopes.back()->setHasIndirectGoto();
1521 }
1522
1523 BlockScopeInfo *Sema::getCurBlock() {
1524   if (FunctionScopes.empty())
1525     return nullptr;
1526
1527   auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1528   if (CurBSI && CurBSI->TheDecl &&
1529       !CurBSI->TheDecl->Encloses(CurContext)) {
1530     // We have switched contexts due to template instantiation.
1531     assert(!CodeSynthesisContexts.empty());
1532     return nullptr;
1533   }
1534
1535   return CurBSI;
1536 }
1537
1538 FunctionScopeInfo *Sema::getEnclosingFunction() const {
1539   if (FunctionScopes.empty())
1540     return nullptr;
1541
1542   for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1543     if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1544       continue;
1545     return FunctionScopes[e];
1546   }
1547   return nullptr;
1548 }
1549
1550 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1551   if (FunctionScopes.empty())
1552     return nullptr;
1553
1554   auto I = FunctionScopes.rbegin();
1555   if (IgnoreNonLambdaCapturingScope) {
1556     auto E = FunctionScopes.rend();
1557     while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1558       ++I;
1559     if (I == E)
1560       return nullptr;
1561   }
1562   auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1563   if (CurLSI && CurLSI->Lambda &&
1564       !CurLSI->Lambda->Encloses(CurContext)) {
1565     // We have switched contexts due to template instantiation.
1566     assert(!CodeSynthesisContexts.empty());
1567     return nullptr;
1568   }
1569
1570   return CurLSI;
1571 }
1572 // We have a generic lambda if we parsed auto parameters, or we have
1573 // an associated template parameter list.
1574 LambdaScopeInfo *Sema::getCurGenericLambda() {
1575   if (LambdaScopeInfo *LSI =  getCurLambda()) {
1576     return (LSI->AutoTemplateParams.size() ||
1577                     LSI->GLTemplateParameterList) ? LSI : nullptr;
1578   }
1579   return nullptr;
1580 }
1581
1582
1583 void Sema::ActOnComment(SourceRange Comment) {
1584   if (!LangOpts.RetainCommentsFromSystemHeaders &&
1585       SourceMgr.isInSystemHeader(Comment.getBegin()))
1586     return;
1587   RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1588   if (RC.isAlmostTrailingComment()) {
1589     SourceRange MagicMarkerRange(Comment.getBegin(),
1590                                  Comment.getBegin().getLocWithOffset(3));
1591     StringRef MagicMarkerText;
1592     switch (RC.getKind()) {
1593     case RawComment::RCK_OrdinaryBCPL:
1594       MagicMarkerText = "///<";
1595       break;
1596     case RawComment::RCK_OrdinaryC:
1597       MagicMarkerText = "/**<";
1598       break;
1599     default:
1600       llvm_unreachable("if this is an almost Doxygen comment, "
1601                        "it should be ordinary");
1602     }
1603     Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1604       FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1605   }
1606   Context.addComment(RC);
1607 }
1608
1609 // Pin this vtable to this file.
1610 ExternalSemaSource::~ExternalSemaSource() {}
1611
1612 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1613 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
1614
1615 void ExternalSemaSource::ReadKnownNamespaces(
1616                            SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1617 }
1618
1619 void ExternalSemaSource::ReadUndefinedButUsed(
1620     llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1621
1622 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1623     FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1624
1625 /// Figure out if an expression could be turned into a call.
1626 ///
1627 /// Use this when trying to recover from an error where the programmer may have
1628 /// written just the name of a function instead of actually calling it.
1629 ///
1630 /// \param E - The expression to examine.
1631 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1632 ///  with no arguments, this parameter is set to the type returned by such a
1633 ///  call; otherwise, it is set to an empty QualType.
1634 /// \param OverloadSet - If the expression is an overloaded function
1635 ///  name, this parameter is populated with the decls of the various overloads.
1636 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1637                          UnresolvedSetImpl &OverloadSet) {
1638   ZeroArgCallReturnTy = QualType();
1639   OverloadSet.clear();
1640
1641   const OverloadExpr *Overloads = nullptr;
1642   bool IsMemExpr = false;
1643   if (E.getType() == Context.OverloadTy) {
1644     OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1645
1646     // Ignore overloads that are pointer-to-member constants.
1647     if (FR.HasFormOfMemberPointer)
1648       return false;
1649
1650     Overloads = FR.Expression;
1651   } else if (E.getType() == Context.BoundMemberTy) {
1652     Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1653     IsMemExpr = true;
1654   }
1655
1656   bool Ambiguous = false;
1657   bool IsMV = false;
1658
1659   if (Overloads) {
1660     for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1661          DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1662       OverloadSet.addDecl(*it);
1663
1664       // Check whether the function is a non-template, non-member which takes no
1665       // arguments.
1666       if (IsMemExpr)
1667         continue;
1668       if (const FunctionDecl *OverloadDecl
1669             = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1670         if (OverloadDecl->getMinRequiredArguments() == 0) {
1671           if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1672               (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1673                           OverloadDecl->isCPUSpecificMultiVersion()))) {
1674             ZeroArgCallReturnTy = QualType();
1675             Ambiguous = true;
1676           } else {
1677             ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1678             IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1679                    OverloadDecl->isCPUSpecificMultiVersion();
1680           }
1681         }
1682       }
1683     }
1684
1685     // If it's not a member, use better machinery to try to resolve the call
1686     if (!IsMemExpr)
1687       return !ZeroArgCallReturnTy.isNull();
1688   }
1689
1690   // Attempt to call the member with no arguments - this will correctly handle
1691   // member templates with defaults/deduction of template arguments, overloads
1692   // with default arguments, etc.
1693   if (IsMemExpr && !E.isTypeDependent()) {
1694     bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1695     getDiagnostics().setSuppressAllDiagnostics(true);
1696     ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1697                                              None, SourceLocation());
1698     getDiagnostics().setSuppressAllDiagnostics(Suppress);
1699     if (R.isUsable()) {
1700       ZeroArgCallReturnTy = R.get()->getType();
1701       return true;
1702     }
1703     return false;
1704   }
1705
1706   if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1707     if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1708       if (Fun->getMinRequiredArguments() == 0)
1709         ZeroArgCallReturnTy = Fun->getReturnType();
1710       return true;
1711     }
1712   }
1713
1714   // We don't have an expression that's convenient to get a FunctionDecl from,
1715   // but we can at least check if the type is "function of 0 arguments".
1716   QualType ExprTy = E.getType();
1717   const FunctionType *FunTy = nullptr;
1718   QualType PointeeTy = ExprTy->getPointeeType();
1719   if (!PointeeTy.isNull())
1720     FunTy = PointeeTy->getAs<FunctionType>();
1721   if (!FunTy)
1722     FunTy = ExprTy->getAs<FunctionType>();
1723
1724   if (const FunctionProtoType *FPT =
1725       dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1726     if (FPT->getNumParams() == 0)
1727       ZeroArgCallReturnTy = FunTy->getReturnType();
1728     return true;
1729   }
1730   return false;
1731 }
1732
1733 /// Give notes for a set of overloads.
1734 ///
1735 /// A companion to tryExprAsCall. In cases when the name that the programmer
1736 /// wrote was an overloaded function, we may be able to make some guesses about
1737 /// plausible overloads based on their return types; such guesses can be handed
1738 /// off to this method to be emitted as notes.
1739 ///
1740 /// \param Overloads - The overloads to note.
1741 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1742 ///  -fshow-overloads=best, this is the location to attach to the note about too
1743 ///  many candidates. Typically this will be the location of the original
1744 ///  ill-formed expression.
1745 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1746                           const SourceLocation FinalNoteLoc) {
1747   int ShownOverloads = 0;
1748   int SuppressedOverloads = 0;
1749   for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1750        DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1751     // FIXME: Magic number for max shown overloads stolen from
1752     // OverloadCandidateSet::NoteCandidates.
1753     if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1754       ++SuppressedOverloads;
1755       continue;
1756     }
1757
1758     NamedDecl *Fn = (*It)->getUnderlyingDecl();
1759     // Don't print overloads for non-default multiversioned functions.
1760     if (const auto *FD = Fn->getAsFunction()) {
1761       if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1762           !FD->getAttr<TargetAttr>()->isDefaultVersion())
1763         continue;
1764     }
1765     S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1766     ++ShownOverloads;
1767   }
1768
1769   if (SuppressedOverloads)
1770     S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1771       << SuppressedOverloads;
1772 }
1773
1774 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1775                                    const UnresolvedSetImpl &Overloads,
1776                                    bool (*IsPlausibleResult)(QualType)) {
1777   if (!IsPlausibleResult)
1778     return noteOverloads(S, Overloads, Loc);
1779
1780   UnresolvedSet<2> PlausibleOverloads;
1781   for (OverloadExpr::decls_iterator It = Overloads.begin(),
1782          DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1783     const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1784     QualType OverloadResultTy = OverloadDecl->getReturnType();
1785     if (IsPlausibleResult(OverloadResultTy))
1786       PlausibleOverloads.addDecl(It.getDecl());
1787   }
1788   noteOverloads(S, PlausibleOverloads, Loc);
1789 }
1790
1791 /// Determine whether the given expression can be called by just
1792 /// putting parentheses after it.  Notably, expressions with unary
1793 /// operators can't be because the unary operator will start parsing
1794 /// outside the call.
1795 static bool IsCallableWithAppend(Expr *E) {
1796   E = E->IgnoreImplicit();
1797   return (!isa<CStyleCastExpr>(E) &&
1798           !isa<UnaryOperator>(E) &&
1799           !isa<BinaryOperator>(E) &&
1800           !isa<CXXOperatorCallExpr>(E));
1801 }
1802
1803 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
1804   if (const auto *UO = dyn_cast<UnaryOperator>(E))
1805     E = UO->getSubExpr();
1806
1807   if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1808     if (ULE->getNumDecls() == 0)
1809       return false;
1810
1811     const NamedDecl *ND = *ULE->decls_begin();
1812     if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1813       return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1814   }
1815   return false;
1816 }
1817
1818 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1819                                 bool ForceComplain,
1820                                 bool (*IsPlausibleResult)(QualType)) {
1821   SourceLocation Loc = E.get()->getExprLoc();
1822   SourceRange Range = E.get()->getSourceRange();
1823
1824   QualType ZeroArgCallTy;
1825   UnresolvedSet<4> Overloads;
1826   if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1827       !ZeroArgCallTy.isNull() &&
1828       (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1829     // At this point, we know E is potentially callable with 0
1830     // arguments and that it returns something of a reasonable type,
1831     // so we can emit a fixit and carry on pretending that E was
1832     // actually a CallExpr.
1833     SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1834     bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1835     Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1836                   << (IsCallableWithAppend(E.get())
1837                           ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1838                           : FixItHint());
1839     if (!IsMV)
1840       notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1841
1842     // FIXME: Try this before emitting the fixit, and suppress diagnostics
1843     // while doing so.
1844     E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1845                       Range.getEnd().getLocWithOffset(1));
1846     return true;
1847   }
1848
1849   if (!ForceComplain) return false;
1850
1851   bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1852   Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1853   if (!IsMV)
1854     notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1855   E = ExprError();
1856   return true;
1857 }
1858
1859 IdentifierInfo *Sema::getSuperIdentifier() const {
1860   if (!Ident_super)
1861     Ident_super = &Context.Idents.get("super");
1862   return Ident_super;
1863 }
1864
1865 IdentifierInfo *Sema::getFloat128Identifier() const {
1866   if (!Ident___float128)
1867     Ident___float128 = &Context.Idents.get("__float128");
1868   return Ident___float128;
1869 }
1870
1871 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
1872                                    CapturedRegionKind K) {
1873   CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
1874       getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1875       (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1876   CSI->ReturnType = Context.VoidTy;
1877   FunctionScopes.push_back(CSI);
1878 }
1879
1880 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1881   if (FunctionScopes.empty())
1882     return nullptr;
1883
1884   return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1885 }
1886
1887 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1888 Sema::getMismatchingDeleteExpressions() const {
1889   return DeleteExprs;
1890 }
1891
1892 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1893   if (ExtStr.empty())
1894     return;
1895   llvm::SmallVector<StringRef, 1> Exts;
1896   ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1897   auto CanT = T.getCanonicalType().getTypePtr();
1898   for (auto &I : Exts)
1899     OpenCLTypeExtMap[CanT].insert(I.str());
1900 }
1901
1902 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1903   llvm::SmallVector<StringRef, 1> Exts;
1904   ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1905   if (Exts.empty())
1906     return;
1907   for (auto &I : Exts)
1908     OpenCLDeclExtMap[FD].insert(I.str());
1909 }
1910
1911 void Sema::setCurrentOpenCLExtensionForType(QualType T) {
1912   if (CurrOpenCLExtension.empty())
1913     return;
1914   setOpenCLExtensionForType(T, CurrOpenCLExtension);
1915 }
1916
1917 void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
1918   if (CurrOpenCLExtension.empty())
1919     return;
1920   setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1921 }
1922
1923 std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
1924   if (!OpenCLDeclExtMap.empty())
1925     return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1926
1927   return "";
1928 }
1929
1930 std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
1931   if (!OpenCLTypeExtMap.empty())
1932     return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1933
1934   return "";
1935 }
1936
1937 template <typename T, typename MapT>
1938 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1939   std::string ExtensionNames = "";
1940   auto Loc = Map.find(FDT);
1941
1942   for (auto const& I : Loc->second) {
1943     ExtensionNames += I;
1944     ExtensionNames += " ";
1945   }
1946   ExtensionNames.pop_back();
1947
1948   return ExtensionNames;
1949 }
1950
1951 bool Sema::isOpenCLDisabledDecl(Decl *FD) {
1952   auto Loc = OpenCLDeclExtMap.find(FD);
1953   if (Loc == OpenCLDeclExtMap.end())
1954     return false;
1955   for (auto &I : Loc->second) {
1956     if (!getOpenCLOptions().isEnabled(I))
1957       return true;
1958   }
1959   return false;
1960 }
1961
1962 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1963 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1964                                          DiagInfoT DiagInfo, MapT &Map,
1965                                          unsigned Selector,
1966                                          SourceRange SrcRange) {
1967   auto Loc = Map.find(D);
1968   if (Loc == Map.end())
1969     return false;
1970   bool Disabled = false;
1971   for (auto &I : Loc->second) {
1972     if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1973       Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1974                                                          << I << SrcRange;
1975       Disabled = true;
1976     }
1977   }
1978   return Disabled;
1979 }
1980
1981 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
1982   // Check extensions for declared types.
1983   Decl *Decl = nullptr;
1984   if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1985     Decl = TypedefT->getDecl();
1986   if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1987     Decl = TagT->getDecl();
1988   auto Loc = DS.getTypeSpecTypeLoc();
1989
1990   // Check extensions for vector types.
1991   // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1992   if (QT->isExtVectorType()) {
1993     auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1994     return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1995   }
1996
1997   if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
1998     return true;
1999
2000   // Check extensions for builtin types.
2001   return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2002                                        QT, OpenCLTypeExtMap);
2003 }
2004
2005 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2006   IdentifierInfo *FnName = D.getIdentifier();
2007   return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2008                                        OpenCLDeclExtMap, 1, D.getSourceRange());
2009 }