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