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