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

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