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