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