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

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