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