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