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().ObjC)
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 // Initialization 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().ObjC) {
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"
323 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
324 addImplicitTypedef(#ExtType, Context.Id##Ty); \
325 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
326 #include "clang/Basic/OpenCLExtensionTypes.def"
329 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
330 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
331 if (IdResolver.begin(MSVaList) == IdResolver.end())
332 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
335 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
336 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
337 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
341 if (VisContext) FreeVisContext();
343 // Kill all the active scopes.
344 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
345 if (FSI != PreallocatedFunctionScope.get())
348 // Tell the SemaConsumer to forget about us; we're going out of scope.
349 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
352 // Detach from the external Sema source.
353 if (ExternalSemaSource *ExternalSema
354 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
355 ExternalSema->ForgetSema();
357 // If Sema's ExternalSource is the multiplexer - we own it.
358 if (isMultiplexExternalSource)
359 delete ExternalSource;
361 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
363 // Destroys data sharing attributes stack for OpenMP
364 DestroyDataSharingAttributesStack();
366 // Detach from the PP callback handler which outlives Sema since it's owned
367 // by the preprocessor.
368 SemaPPCallbackHandler->reset();
370 assert(DelayedTypos.empty() && "Uncorrected typos!");
373 /// makeUnavailableInSystemHeader - There is an error in the current
374 /// context. If we're still in a system header, and we can plausibly
375 /// make the relevant declaration unavailable instead of erroring, do
376 /// so and return true.
377 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
378 UnavailableAttr::ImplicitReason reason) {
379 // If we're not in a function, it's an error.
380 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
381 if (!fn) return false;
383 // If we're in template instantiation, it's an error.
384 if (inTemplateInstantiation())
387 // If that function's not in a system header, it's an error.
388 if (!Context.getSourceManager().isInSystemHeader(loc))
391 // If the function is already unavailable, it's not an error.
392 if (fn->hasAttr<UnavailableAttr>()) return true;
394 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
398 ASTMutationListener *Sema::getASTMutationListener() const {
399 return getASTConsumer().GetASTMutationListener();
402 ///Registers an external source. If an external source already exists,
403 /// creates a multiplex external source and appends to it.
405 ///\param[in] E - A non-null external sema source.
407 void Sema::addExternalSource(ExternalSemaSource *E) {
408 assert(E && "Cannot use with NULL ptr");
410 if (!ExternalSource) {
415 if (isMultiplexExternalSource)
416 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
418 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
419 isMultiplexExternalSource = true;
423 /// Print out statistics about the semantic analysis.
424 void Sema::PrintStats() const {
425 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
426 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
428 BumpAlloc.PrintStats();
429 AnalysisWarnings.PrintStats();
432 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
434 SourceLocation Loc) {
435 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
436 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
439 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
440 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
443 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
446 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
447 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
450 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
451 if (!getLangOpts().CPlusPlus11)
454 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
456 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
459 // If it is a macro from system header, and if the macro name is not "NULL",
461 SourceLocation MaybeMacroLoc = E->getBeginLoc();
462 if (Diags.getSuppressSystemWarnings() &&
463 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
464 !findMacroSpelling(MaybeMacroLoc, "NULL"))
467 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
468 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
471 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
472 /// If there is already an implicit cast, merge into the existing one.
473 /// The result is of the given category.
474 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
475 CastKind Kind, ExprValueKind VK,
476 const CXXCastPath *BasePath,
477 CheckedConversionKind CCK) {
479 if (VK == VK_RValue && !E->isRValue()) {
482 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
484 case CK_LValueToRValue:
485 case CK_ArrayToPointerDecay:
486 case CK_FunctionToPointerDecay:
488 case CK_NonAtomicToAtomic:
492 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
495 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
496 diagnoseZeroToNullptrConversion(Kind, E);
498 QualType ExprTy = Context.getCanonicalType(E->getType());
499 QualType TypeTy = Context.getCanonicalType(Ty);
501 if (ExprTy == TypeTy)
504 // C++1z [conv.array]: The temporary materialization conversion is applied.
505 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
506 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
507 E->getValueKind() == VK_RValue) {
508 // The temporary is an lvalue in C++98 and an xvalue otherwise.
509 ExprResult Materialized = CreateMaterializeTemporaryExpr(
510 E->getType(), E, !getLangOpts().CPlusPlus11);
511 if (Materialized.isInvalid())
513 E = Materialized.get();
516 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
517 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
518 ImpCast->setType(Ty);
519 ImpCast->setValueKind(VK);
524 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
527 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
528 /// to the conversion from scalar type ScalarTy to the Boolean type.
529 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
530 switch (ScalarTy->getScalarTypeKind()) {
531 case Type::STK_Bool: return CK_NoOp;
532 case Type::STK_CPointer: return CK_PointerToBoolean;
533 case Type::STK_BlockPointer: return CK_PointerToBoolean;
534 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
535 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
536 case Type::STK_Integral: return CK_IntegralToBoolean;
537 case Type::STK_Floating: return CK_FloatingToBoolean;
538 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
539 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
540 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
542 llvm_unreachable("unknown scalar type kind");
545 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
546 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
547 if (D->getMostRecentDecl()->isUsed())
550 if (D->isExternallyVisible())
553 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
554 // If this is a function template and none of its specializations is used,
556 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
557 for (const auto *Spec : Template->specializations())
558 if (ShouldRemoveFromUnused(SemaRef, Spec))
561 // UnusedFileScopedDecls stores the first declaration.
562 // The declaration may have become definition so check again.
563 const FunctionDecl *DeclToCheck;
564 if (FD->hasBody(DeclToCheck))
565 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
567 // Later redecls may add new information resulting in not having to warn,
569 DeclToCheck = FD->getMostRecentDecl();
570 if (DeclToCheck != FD)
571 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
574 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
575 // If a variable usable in constant expressions is referenced,
576 // don't warn if it isn't used: if the value of a variable is required
577 // for the computation of a constant expression, it doesn't make sense to
578 // warn even if the variable isn't odr-used. (isReferenced doesn't
579 // precisely reflect that, but it's a decent approximation.)
580 if (VD->isReferenced() &&
581 VD->isUsableInConstantExpressions(SemaRef->Context))
584 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
585 // If this is a variable template and none of its specializations is used,
587 for (const auto *Spec : Template->specializations())
588 if (ShouldRemoveFromUnused(SemaRef, Spec))
591 // UnusedFileScopedDecls stores the first declaration.
592 // The declaration may have become definition so check again.
593 const VarDecl *DeclToCheck = VD->getDefinition();
595 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
597 // Later redecls may add new information resulting in not having to warn,
599 DeclToCheck = VD->getMostRecentDecl();
600 if (DeclToCheck != VD)
601 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
607 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
608 if (auto *FD = dyn_cast<FunctionDecl>(ND))
609 return FD->isExternC();
610 return cast<VarDecl>(ND)->isExternC();
613 /// Determine whether ND is an external-linkage function or variable whose
614 /// type has no linkage.
615 bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
616 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
617 // because we also want to catch the case where its type has VisibleNoLinkage,
618 // which does not affect the linkage of VD.
619 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
620 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
621 !isFunctionOrVarDeclExternC(VD);
624 /// Obtains a sorted list of functions and variables that are undefined but
626 void Sema::getUndefinedButUsed(
627 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
628 for (const auto &UndefinedUse : UndefinedButUsed) {
629 NamedDecl *ND = UndefinedUse.first;
631 // Ignore attributes that have become invalid.
632 if (ND->isInvalidDecl()) continue;
634 // __attribute__((weakref)) is basically a definition.
635 if (ND->hasAttr<WeakRefAttr>()) continue;
637 if (isa<CXXDeductionGuideDecl>(ND))
640 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
641 // An exported function will always be emitted when defined, so even if
642 // the function is inline, it doesn't have to be emitted in this TU. An
643 // imported function implies that it has been exported somewhere else.
647 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
650 if (FD->isExternallyVisible() &&
651 !isExternalWithNoLinkageType(FD) &&
652 !FD->getMostRecentDecl()->isInlined() &&
653 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
655 if (FD->getBuiltinID())
658 auto *VD = cast<VarDecl>(ND);
659 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
661 if (VD->isExternallyVisible() &&
662 !isExternalWithNoLinkageType(VD) &&
663 !VD->getMostRecentDecl()->isInline() &&
664 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
667 // Skip VarDecls that lack formal definitions but which we know are in
668 // fact defined somewhere.
669 if (VD->isKnownToBeDefined())
673 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
677 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
678 /// or that are inline.
679 static void checkUndefinedButUsed(Sema &S) {
680 if (S.UndefinedButUsed.empty()) return;
682 // Collect all the still-undefined entities with internal linkage.
683 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
684 S.getUndefinedButUsed(Undefined);
685 if (Undefined.empty()) return;
687 for (auto Undef : Undefined) {
688 ValueDecl *VD = cast<ValueDecl>(Undef.first);
689 SourceLocation UseLoc = Undef.second;
691 if (S.isExternalWithNoLinkageType(VD)) {
692 // C++ [basic.link]p8:
693 // A type without linkage shall not be used as the type of a variable
694 // or function with external linkage unless
695 // -- the entity has C language linkage
696 // -- the entity is not odr-used or is defined in the same TU
698 // As an extension, accept this in cases where the type is externally
699 // visible, since the function or variable actually can be defined in
700 // another translation unit in that case.
701 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
702 ? diag::ext_undefined_internal_type
703 : diag::err_undefined_internal_type)
704 << isa<VarDecl>(VD) << VD;
705 } else if (!VD->isExternallyVisible()) {
706 // FIXME: We can promote this to an error. The function or variable can't
707 // be defined anywhere else, so the program must necessarily violate the
708 // one definition rule.
709 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
710 << isa<VarDecl>(VD) << VD;
711 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
713 assert(FD->getMostRecentDecl()->isInlined() &&
714 "used object requires definition but isn't inline or internal?");
715 // FIXME: This is ill-formed; we should reject.
716 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
718 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
719 "used var requires definition but isn't inline or internal?");
720 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
722 if (UseLoc.isValid())
723 S.Diag(UseLoc, diag::note_used_here);
726 S.UndefinedButUsed.clear();
729 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
733 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
734 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
735 for (auto &WeakID : WeakIDs)
736 WeakUndeclaredIdentifiers.insert(WeakID);
740 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
742 /// Returns true, if all methods and nested classes of the given
743 /// CXXRecordDecl are defined in this translation unit.
745 /// Should only be called from ActOnEndOfTranslationUnit so that all
746 /// definitions are actually read.
747 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
748 RecordCompleteMap &MNCComplete) {
749 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
750 if (Cache != MNCComplete.end())
751 return Cache->second;
752 if (!RD->isCompleteDefinition())
754 bool Complete = true;
755 for (DeclContext::decl_iterator I = RD->decls_begin(),
757 I != E && Complete; ++I) {
758 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
759 Complete = M->isDefined() || M->isDefaulted() ||
760 (M->isPure() && !isa<CXXDestructorDecl>(M));
761 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
762 // If the template function is marked as late template parsed at this
763 // point, it has not been instantiated and therefore we have not
764 // performed semantic analysis on it yet, so we cannot know if the type
765 // can be considered complete.
766 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
767 F->getTemplatedDecl()->isDefined();
768 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
769 if (R->isInjectedClassName())
771 if (R->hasDefinition())
772 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
778 MNCComplete[RD] = Complete;
782 /// Returns true, if the given CXXRecordDecl is fully defined in this
783 /// translation unit, i.e. all methods are defined or pure virtual and all
784 /// friends, friend functions and nested classes are fully defined in this
785 /// translation unit.
787 /// Should only be called from ActOnEndOfTranslationUnit so that all
788 /// definitions are actually read.
789 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
790 RecordCompleteMap &RecordsComplete,
791 RecordCompleteMap &MNCComplete) {
792 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
793 if (Cache != RecordsComplete.end())
794 return Cache->second;
795 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
796 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
797 E = RD->friend_end();
798 I != E && Complete; ++I) {
799 // Check if friend classes and methods are complete.
800 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
801 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
802 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
803 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
807 // Friend functions are available through the NamedDecl of FriendDecl.
808 if (const FunctionDecl *FD =
809 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
810 Complete = FD->isDefined();
812 // This is a template friend, give up.
816 RecordsComplete[RD] = Complete;
820 void Sema::emitAndClearUnusedLocalTypedefWarnings() {
822 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
823 UnusedLocalTypedefNameCandidates);
824 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
825 if (TD->isReferenced())
827 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
828 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
830 UnusedLocalTypedefNameCandidates.clear();
833 /// This is called before the very first declaration in the translation unit
834 /// is parsed. Note that the ASTContext may have already injected some
836 void Sema::ActOnStartOfTranslationUnit() {
837 if (getLangOpts().ModulesTS &&
838 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
839 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
840 SourceLocation StartOfTU =
841 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
843 // We start in the global module; all those declarations are implicitly
844 // module-private (though they do not have module linkage).
845 auto &Map = PP.getHeaderSearchInfo().getModuleMap();
846 auto *GlobalModule = Map.createGlobalModuleForInterfaceUnit(StartOfTU);
847 assert(GlobalModule && "module creation should not fail");
849 // Enter the scope of the global module.
850 ModuleScopes.push_back({});
851 ModuleScopes.back().Module = GlobalModule;
852 VisibleModules.setVisible(GlobalModule, StartOfTU);
854 // All declarations created from now on are owned by the global module.
855 auto *TU = Context.getTranslationUnitDecl();
856 TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
857 TU->setLocalOwningModule(GlobalModule);
861 /// ActOnEndOfTranslationUnit - This is called at the very end of the
862 /// translation unit when EOF is reached and all but the top-level scope is
864 void Sema::ActOnEndOfTranslationUnit() {
865 assert(DelayedDiagnostics.getCurrentPool() == nullptr
866 && "reached end of translation unit with a pool attached?");
868 // If code completion is enabled, don't perform any end-of-translation-unit
870 if (PP.isCodeCompletionEnabled())
873 // Transfer late parsed template instantiations over to the pending template
874 // instantiation list. During normal compliation, the late template parser
875 // will be installed and instantiating these templates will succeed.
877 // If we are building a TU prefix for serialization, it is also safe to
878 // transfer these over, even though they are not parsed. The end of the TU
879 // should be outside of any eager template instantiation scope, so when this
880 // AST is deserialized, these templates will not be parsed until the end of
882 PendingInstantiations.insert(PendingInstantiations.end(),
883 LateParsedInstantiations.begin(),
884 LateParsedInstantiations.end());
885 LateParsedInstantiations.clear();
887 // Complete translation units and modules define vtables and perform implicit
888 // instantiations. PCH files do not.
889 if (TUKind != TU_Prefix) {
890 DiagnoseUseOfUnimplementedSelectors();
892 // If DefinedUsedVTables ends up marking any virtual member functions it
893 // might lead to more pending template instantiations, which we then need
897 // C++: Perform implicit template instantiations.
899 // FIXME: When we perform these implicit instantiations, we do not
900 // carefully keep track of the point of instantiation (C++ [temp.point]).
901 // This means that name lookup that occurs within the template
902 // instantiation will always happen at the end of the translation unit,
903 // so it will find some names that are not required to be found. This is
904 // valid, but we could do better by diagnosing if an instantiation uses a
905 // name that was not visible at its first point of instantiation.
906 if (ExternalSource) {
907 // Load pending instantiations from the external source.
908 SmallVector<PendingImplicitInstantiation, 4> Pending;
909 ExternalSource->ReadPendingInstantiations(Pending);
910 for (auto PII : Pending)
911 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
912 Func->setInstantiationIsPending(true);
913 PendingInstantiations.insert(PendingInstantiations.begin(),
914 Pending.begin(), Pending.end());
917 PerformPendingInstantiations();
919 assert(LateParsedInstantiations.empty() &&
920 "end of TU template instantiation should not create more "
921 "late-parsed templates");
923 if (LateTemplateParserCleanup)
924 LateTemplateParserCleanup(OpaqueParser);
926 CheckDelayedMemberExceptionSpecs();
929 DiagnoseUnterminatedPragmaPack();
930 DiagnoseUnterminatedPragmaAttribute();
932 // All delayed member exception specs should be checked or we end up accepting
933 // incompatible declarations.
934 assert(DelayedOverridingExceptionSpecChecks.empty());
935 assert(DelayedEquivalentExceptionSpecChecks.empty());
936 assert(DelayedDefaultedMemberExceptionSpecs.empty());
938 // All dllexport classes should have been processed already.
939 assert(DelayedDllExportClasses.empty());
941 // Remove file scoped decls that turned out to be used.
942 UnusedFileScopedDecls.erase(
943 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
944 UnusedFileScopedDecls.end(),
945 [this](const DeclaratorDecl *DD) {
946 return ShouldRemoveFromUnused(this, DD);
948 UnusedFileScopedDecls.end());
950 if (TUKind == TU_Prefix) {
951 // Translation unit prefixes don't need any of the checking below.
952 if (!PP.isIncrementalProcessingEnabled())
957 // Check for #pragma weak identifiers that were never declared
958 LoadExternalWeakUndeclaredIdentifiers();
959 for (auto WeakID : WeakUndeclaredIdentifiers) {
960 if (WeakID.second.getUsed())
963 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
965 if (PrevDecl != nullptr &&
966 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
967 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
968 << "'weak'" << ExpectedVariableOrFunction;
970 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
974 if (LangOpts.CPlusPlus11 &&
975 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
976 CheckDelegatingCtorCycles();
978 if (!Diags.hasErrorOccurred()) {
980 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
981 checkUndefinedButUsed(*this);
984 if (TUKind == TU_Module) {
985 // If we are building a module interface unit, we need to have seen the
986 // module declaration by now.
987 if (getLangOpts().getCompilingModule() ==
988 LangOptions::CMK_ModuleInterface &&
989 (ModuleScopes.empty() ||
990 ModuleScopes.back().Module->Kind != Module::ModuleInterfaceUnit)) {
991 // FIXME: Make a better guess as to where to put the module declaration.
992 Diag(getSourceManager().getLocForStartOfFile(
993 getSourceManager().getMainFileID()),
994 diag::err_module_declaration_missing);
997 // If we are building a module, resolve all of the exported declarations
999 if (Module *CurrentModule = PP.getCurrentModule()) {
1000 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
1002 SmallVector<Module *, 2> Stack;
1003 Stack.push_back(CurrentModule);
1004 while (!Stack.empty()) {
1005 Module *Mod = Stack.pop_back_val();
1007 // Resolve the exported declarations and conflicts.
1008 // FIXME: Actually complain, once we figure out how to teach the
1009 // diagnostic client to deal with complaints in the module map at this
1011 ModMap.resolveExports(Mod, /*Complain=*/false);
1012 ModMap.resolveUses(Mod, /*Complain=*/false);
1013 ModMap.resolveConflicts(Mod, /*Complain=*/false);
1015 // Queue the submodules, so their exports will also be resolved.
1016 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1020 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1021 // modules when they are built, not every time they are used.
1022 emitAndClearUnusedLocalTypedefWarnings();
1026 // A declaration of an identifier for an object that has file
1027 // scope without an initializer, and without a storage-class
1028 // specifier or with the storage-class specifier static,
1029 // constitutes a tentative definition. If a translation unit
1030 // contains one or more tentative definitions for an identifier,
1031 // and the translation unit contains no external definition for
1032 // that identifier, then the behavior is exactly as if the
1033 // translation unit contains a file scope declaration of that
1034 // identifier, with the composite type as of the end of the
1035 // translation unit, with an initializer equal to 0.
1036 llvm::SmallSet<VarDecl *, 32> Seen;
1037 for (TentativeDefinitionsType::iterator
1038 T = TentativeDefinitions.begin(ExternalSource),
1039 TEnd = TentativeDefinitions.end();
1041 VarDecl *VD = (*T)->getActingDefinition();
1043 // If the tentative definition was completed, getActingDefinition() returns
1044 // null. If we've already seen this variable before, insert()'s second
1045 // return value is false.
1046 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1049 if (const IncompleteArrayType *ArrayT
1050 = Context.getAsIncompleteArrayType(VD->getType())) {
1051 // Set the length of the array to 1 (C99 6.9.2p5).
1052 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1053 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1054 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1055 One, ArrayType::Normal, 0);
1057 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1058 diag::err_tentative_def_incomplete_type))
1059 VD->setInvalidDecl();
1061 // No initialization is performed for a tentative definition.
1062 CheckCompleteVariableDeclaration(VD);
1064 // Notify the consumer that we've completed a tentative definition.
1065 if (!VD->isInvalidDecl())
1066 Consumer.CompleteTentativeDefinition(VD);
1069 // If there were errors, disable 'unused' warnings since they will mostly be
1070 // noise. Don't warn for a use from a module: either we should warn on all
1071 // file-scope declarations in modules or not at all, but whether the
1072 // declaration is used is immaterial.
1073 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1074 // Output warning for unused file scoped decls.
1075 for (UnusedFileScopedDeclsType::iterator
1076 I = UnusedFileScopedDecls.begin(ExternalSource),
1077 E = UnusedFileScopedDecls.end(); I != E; ++I) {
1078 if (ShouldRemoveFromUnused(this, *I))
1081 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1082 const FunctionDecl *DiagD;
1083 if (!FD->hasBody(DiagD))
1085 if (DiagD->isDeleted())
1086 continue; // Deleted functions are supposed to be unused.
1087 if (DiagD->isReferenced()) {
1088 if (isa<CXXMethodDecl>(DiagD))
1089 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1090 << DiagD->getDeclName();
1092 if (FD->getStorageClass() == SC_Static &&
1093 !FD->isInlineSpecified() &&
1094 !SourceMgr.isInMainFile(
1095 SourceMgr.getExpansionLoc(FD->getLocation())))
1096 Diag(DiagD->getLocation(),
1097 diag::warn_unneeded_static_internal_decl)
1098 << DiagD->getDeclName();
1100 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1101 << /*function*/0 << DiagD->getDeclName();
1104 if (FD->getDescribedFunctionTemplate())
1105 Diag(DiagD->getLocation(), diag::warn_unused_template)
1106 << /*function*/0 << DiagD->getDeclName();
1108 Diag(DiagD->getLocation(),
1109 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1110 : diag::warn_unused_function)
1111 << DiagD->getDeclName();
1114 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1116 DiagD = cast<VarDecl>(*I);
1117 if (DiagD->isReferenced()) {
1118 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1119 << /*variable*/1 << DiagD->getDeclName();
1120 } else if (DiagD->getType().isConstQualified()) {
1121 const SourceManager &SM = SourceMgr;
1122 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1123 !PP.getLangOpts().IsHeaderFile)
1124 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1125 << DiagD->getDeclName();
1127 if (DiagD->getDescribedVarTemplate())
1128 Diag(DiagD->getLocation(), diag::warn_unused_template)
1129 << /*variable*/1 << DiagD->getDeclName();
1131 Diag(DiagD->getLocation(), diag::warn_unused_variable)
1132 << DiagD->getDeclName();
1137 emitAndClearUnusedLocalTypedefWarnings();
1140 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1141 // FIXME: Load additional unused private field candidates from the external
1143 RecordCompleteMap RecordsComplete;
1144 RecordCompleteMap MNCComplete;
1145 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1146 E = UnusedPrivateFields.end(); I != E; ++I) {
1147 const NamedDecl *D = *I;
1148 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1149 if (RD && !RD->isUnion() &&
1150 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1151 Diag(D->getLocation(), diag::warn_unused_private_field)
1152 << D->getDeclName();
1157 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1159 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1160 for (const auto &DeletedFieldInfo : DeleteExprs) {
1161 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1162 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1163 DeleteExprLoc.second);
1168 // Check we've noticed that we're no longer parsing the initializer for every
1169 // variable. If we miss cases, then at best we have a performance issue and
1170 // at worst a rejects-valid bug.
1171 assert(ParsingInitForAutoVars.empty() &&
1172 "Didn't unmark var as having its initializer parsed");
1174 if (!PP.isIncrementalProcessingEnabled())
1179 //===----------------------------------------------------------------------===//
1180 // Helper functions.
1181 //===----------------------------------------------------------------------===//
1183 DeclContext *Sema::getFunctionLevelDeclContext() {
1184 DeclContext *DC = CurContext;
1187 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1188 DC = DC->getParent();
1189 } else if (isa<CXXMethodDecl>(DC) &&
1190 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1191 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1192 DC = DC->getParent()->getParent();
1200 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1201 /// to the function decl for the function being parsed. If we're currently
1202 /// in a 'block', this returns the containing context.
1203 FunctionDecl *Sema::getCurFunctionDecl() {
1204 DeclContext *DC = getFunctionLevelDeclContext();
1205 return dyn_cast<FunctionDecl>(DC);
1208 ObjCMethodDecl *Sema::getCurMethodDecl() {
1209 DeclContext *DC = getFunctionLevelDeclContext();
1210 while (isa<RecordDecl>(DC))
1211 DC = DC->getParent();
1212 return dyn_cast<ObjCMethodDecl>(DC);
1215 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
1216 DeclContext *DC = getFunctionLevelDeclContext();
1217 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1218 return cast<NamedDecl>(DC);
1222 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1223 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1224 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1225 // been made more painfully obvious by the refactor that introduced this
1226 // function, but it is possible that the incoming argument can be
1227 // eliminated. If it truly cannot be (for example, there is some reentrancy
1228 // issue I am not seeing yet), then there should at least be a clarifying
1229 // comment somewhere.
1230 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
1231 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1232 Diags.getCurrentDiagID())) {
1233 case DiagnosticIDs::SFINAE_Report:
1234 // We'll report the diagnostic below.
1237 case DiagnosticIDs::SFINAE_SubstitutionFailure:
1238 // Count this failure so that we know that template argument deduction
1242 // Make a copy of this suppressed diagnostic and store it with the
1243 // template-deduction information.
1244 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1245 Diagnostic DiagInfo(&Diags);
1246 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1247 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1250 Diags.setLastDiagnosticIgnored();
1254 case DiagnosticIDs::SFINAE_AccessControl: {
1255 // Per C++ Core Issue 1170, access control is part of SFINAE.
1256 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1257 // make access control a part of SFINAE for the purposes of checking
1259 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
1262 SourceLocation Loc = Diags.getCurrentDiagLoc();
1264 // Suppress this diagnostic.
1267 // Make a copy of this suppressed diagnostic and store it with the
1268 // template-deduction information.
1269 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1270 Diagnostic DiagInfo(&Diags);
1271 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1272 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1275 Diags.setLastDiagnosticIgnored();
1278 // Now the diagnostic state is clear, produce a C++98 compatibility
1280 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1282 // The last diagnostic which Sema produced was ignored. Suppress any
1283 // notes attached to it.
1284 Diags.setLastDiagnosticIgnored();
1288 case DiagnosticIDs::SFINAE_Suppress:
1289 // Make a copy of this suppressed diagnostic and store it with the
1290 // template-deduction information;
1292 Diagnostic DiagInfo(&Diags);
1293 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1294 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1297 // Suppress this diagnostic.
1298 Diags.setLastDiagnosticIgnored();
1304 // Copy the diagnostic printing policy over the ASTContext printing policy.
1305 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1306 Context.setPrintingPolicy(getPrintingPolicy());
1308 // Emit the diagnostic.
1309 if (!Diags.EmitCurrentDiagnostic())
1312 // If this is not a note, and we're in a template instantiation
1313 // that is different from the last template instantiation where
1314 // we emitted an error, print a template instantiation
1316 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1317 PrintContextStack();
1320 Sema::SemaDiagnosticBuilder
1321 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1322 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1328 /// Looks through the macro-expansion chain for the given
1329 /// location, looking for a macro expansion with the given name.
1330 /// If one is found, returns true and sets the location to that
1332 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1333 SourceLocation loc = locref;
1334 if (!loc.isMacroID()) return false;
1336 // There's no good way right now to look at the intermediate
1337 // expansions, so just jump to the expansion location.
1338 loc = getSourceManager().getExpansionLoc(loc);
1340 // If that's written with the name, stop here.
1341 SmallVector<char, 16> buffer;
1342 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1349 /// Determines the active Scope associated with the given declaration
1352 /// This routine maps a declaration context to the active Scope object that
1353 /// represents that declaration context in the parser. It is typically used
1354 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1355 /// declarations) that injects a name for name-lookup purposes and, therefore,
1356 /// must update the Scope.
1358 /// \returns The scope corresponding to the given declaraion context, or NULL
1359 /// if no such scope is open.
1360 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
1365 Ctx = Ctx->getPrimaryContext();
1366 for (Scope *S = getCurScope(); S; S = S->getParent()) {
1367 // Ignore scopes that cannot have declarations. This is important for
1368 // out-of-line definitions of static class members.
1369 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1370 if (DeclContext *Entity = S->getEntity())
1371 if (Ctx == Entity->getPrimaryContext())
1378 /// Enter a new function scope
1379 void Sema::PushFunctionScope() {
1380 if (FunctionScopes.empty()) {
1381 // Use PreallocatedFunctionScope to avoid allocating memory when possible.
1382 PreallocatedFunctionScope->Clear();
1383 FunctionScopes.push_back(PreallocatedFunctionScope.get());
1385 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1387 if (LangOpts.OpenMP)
1388 pushOpenMPFunctionRegion();
1391 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1392 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1393 BlockScope, Block));
1396 LambdaScopeInfo *Sema::PushLambdaScope() {
1397 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1398 FunctionScopes.push_back(LSI);
1402 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1403 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1404 LSI->AutoTemplateParameterDepth = Depth;
1408 "Remove assertion if intentionally called in a non-lambda context.");
1411 // Check that the type of the VarDecl has an accessible copy constructor and
1412 // resolve its destructor's exception spefication.
1413 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1414 QualType T = VD->getType();
1415 EnterExpressionEvaluationContext scope(
1416 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1417 SourceLocation Loc = VD->getLocation();
1419 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1420 ExprResult Result = S.PerformMoveOrCopyInitialization(
1421 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1422 VarRef, /*AllowNRVO=*/true);
1423 if (!Result.isInvalid()) {
1424 Result = S.MaybeCreateExprWithCleanups(Result);
1425 Expr *Init = Result.getAs<Expr>();
1426 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1429 // The destructor's exception spefication is needed when IRGen generates
1430 // block copy/destroy functions. Resolve it here.
1431 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1432 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1433 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1434 S.ResolveExceptionSpec(Loc, FPT);
1438 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1439 // Set the EscapingByref flag of __block variables captured by
1441 for (const BlockDecl *BD : FSI.Blocks) {
1442 if (BD->doesNotEscape())
1444 for (const BlockDecl::Capture &BC : BD->captures()) {
1445 VarDecl *VD = BC.getVariable();
1446 if (VD->hasAttr<BlocksAttr>())
1447 VD->setEscapingByref();
1451 for (VarDecl *VD : FSI.ByrefBlockVars) {
1452 // __block variables might require us to capture a copy-initializer.
1453 if (!VD->isEscapingByref())
1455 // It's currently invalid to ever have a __block variable with an
1456 // array type; should we diagnose that here?
1457 // Regardless, we don't want to ignore array nesting when
1458 // constructing this copy.
1459 if (VD->getType()->isStructureOrClassType())
1460 checkEscapingByref(VD, S);
1464 void Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1465 const Decl *D, const BlockExpr *blkExpr) {
1466 assert(!FunctionScopes.empty() && "mismatched push/pop!");
1468 // This function shouldn't be called after popping the current function scope.
1469 // markEscapingByrefs calls PerformMoveOrCopyInitialization, which can call
1470 // PushFunctionScope, which can cause clearing out PreallocatedFunctionScope
1471 // when FunctionScopes is empty.
1472 markEscapingByrefs(*FunctionScopes.back(), *this);
1474 FunctionScopeInfo *Scope = FunctionScopes.pop_back_val();
1476 if (LangOpts.OpenMP)
1477 popOpenMPFunctionRegion(Scope);
1479 // Issue any analysis-based warnings.
1481 AnalysisWarnings.IssueWarnings(*WP, Scope, D, blkExpr);
1483 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1484 Diag(PUD.Loc, PUD.PD);
1486 // Delete the scope unless its our preallocated scope.
1487 if (Scope != PreallocatedFunctionScope.get())
1491 void Sema::PushCompoundScope(bool IsStmtExpr) {
1492 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1495 void Sema::PopCompoundScope() {
1496 FunctionScopeInfo *CurFunction = getCurFunction();
1497 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1499 CurFunction->CompoundScopes.pop_back();
1502 /// Determine whether any errors occurred within this function/method/
1504 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1505 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1508 void Sema::setFunctionHasBranchIntoScope() {
1509 if (!FunctionScopes.empty())
1510 FunctionScopes.back()->setHasBranchIntoScope();
1513 void Sema::setFunctionHasBranchProtectedScope() {
1514 if (!FunctionScopes.empty())
1515 FunctionScopes.back()->setHasBranchProtectedScope();
1518 void Sema::setFunctionHasIndirectGoto() {
1519 if (!FunctionScopes.empty())
1520 FunctionScopes.back()->setHasIndirectGoto();
1523 BlockScopeInfo *Sema::getCurBlock() {
1524 if (FunctionScopes.empty())
1527 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1528 if (CurBSI && CurBSI->TheDecl &&
1529 !CurBSI->TheDecl->Encloses(CurContext)) {
1530 // We have switched contexts due to template instantiation.
1531 assert(!CodeSynthesisContexts.empty());
1538 FunctionScopeInfo *Sema::getEnclosingFunction() const {
1539 if (FunctionScopes.empty())
1542 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1543 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1545 return FunctionScopes[e];
1550 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1551 if (FunctionScopes.empty())
1554 auto I = FunctionScopes.rbegin();
1555 if (IgnoreNonLambdaCapturingScope) {
1556 auto E = FunctionScopes.rend();
1557 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1562 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1563 if (CurLSI && CurLSI->Lambda &&
1564 !CurLSI->Lambda->Encloses(CurContext)) {
1565 // We have switched contexts due to template instantiation.
1566 assert(!CodeSynthesisContexts.empty());
1572 // We have a generic lambda if we parsed auto parameters, or we have
1573 // an associated template parameter list.
1574 LambdaScopeInfo *Sema::getCurGenericLambda() {
1575 if (LambdaScopeInfo *LSI = getCurLambda()) {
1576 return (LSI->AutoTemplateParams.size() ||
1577 LSI->GLTemplateParameterList) ? LSI : nullptr;
1583 void Sema::ActOnComment(SourceRange Comment) {
1584 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1585 SourceMgr.isInSystemHeader(Comment.getBegin()))
1587 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1588 if (RC.isAlmostTrailingComment()) {
1589 SourceRange MagicMarkerRange(Comment.getBegin(),
1590 Comment.getBegin().getLocWithOffset(3));
1591 StringRef MagicMarkerText;
1592 switch (RC.getKind()) {
1593 case RawComment::RCK_OrdinaryBCPL:
1594 MagicMarkerText = "///<";
1596 case RawComment::RCK_OrdinaryC:
1597 MagicMarkerText = "/**<";
1600 llvm_unreachable("if this is an almost Doxygen comment, "
1601 "it should be ordinary");
1603 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1604 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1606 Context.addComment(RC);
1609 // Pin this vtable to this file.
1610 ExternalSemaSource::~ExternalSemaSource() {}
1612 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1613 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
1615 void ExternalSemaSource::ReadKnownNamespaces(
1616 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1619 void ExternalSemaSource::ReadUndefinedButUsed(
1620 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1622 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1623 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1625 /// Figure out if an expression could be turned into a call.
1627 /// Use this when trying to recover from an error where the programmer may have
1628 /// written just the name of a function instead of actually calling it.
1630 /// \param E - The expression to examine.
1631 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1632 /// with no arguments, this parameter is set to the type returned by such a
1633 /// call; otherwise, it is set to an empty QualType.
1634 /// \param OverloadSet - If the expression is an overloaded function
1635 /// name, this parameter is populated with the decls of the various overloads.
1636 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1637 UnresolvedSetImpl &OverloadSet) {
1638 ZeroArgCallReturnTy = QualType();
1639 OverloadSet.clear();
1641 const OverloadExpr *Overloads = nullptr;
1642 bool IsMemExpr = false;
1643 if (E.getType() == Context.OverloadTy) {
1644 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1646 // Ignore overloads that are pointer-to-member constants.
1647 if (FR.HasFormOfMemberPointer)
1650 Overloads = FR.Expression;
1651 } else if (E.getType() == Context.BoundMemberTy) {
1652 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1656 bool Ambiguous = false;
1660 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1661 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1662 OverloadSet.addDecl(*it);
1664 // Check whether the function is a non-template, non-member which takes no
1668 if (const FunctionDecl *OverloadDecl
1669 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1670 if (OverloadDecl->getMinRequiredArguments() == 0) {
1671 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1672 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1673 OverloadDecl->isCPUSpecificMultiVersion()))) {
1674 ZeroArgCallReturnTy = QualType();
1677 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1678 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1679 OverloadDecl->isCPUSpecificMultiVersion();
1685 // If it's not a member, use better machinery to try to resolve the call
1687 return !ZeroArgCallReturnTy.isNull();
1690 // Attempt to call the member with no arguments - this will correctly handle
1691 // member templates with defaults/deduction of template arguments, overloads
1692 // with default arguments, etc.
1693 if (IsMemExpr && !E.isTypeDependent()) {
1694 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1695 getDiagnostics().setSuppressAllDiagnostics(true);
1696 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1697 None, SourceLocation());
1698 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1700 ZeroArgCallReturnTy = R.get()->getType();
1706 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1707 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1708 if (Fun->getMinRequiredArguments() == 0)
1709 ZeroArgCallReturnTy = Fun->getReturnType();
1714 // We don't have an expression that's convenient to get a FunctionDecl from,
1715 // but we can at least check if the type is "function of 0 arguments".
1716 QualType ExprTy = E.getType();
1717 const FunctionType *FunTy = nullptr;
1718 QualType PointeeTy = ExprTy->getPointeeType();
1719 if (!PointeeTy.isNull())
1720 FunTy = PointeeTy->getAs<FunctionType>();
1722 FunTy = ExprTy->getAs<FunctionType>();
1724 if (const FunctionProtoType *FPT =
1725 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1726 if (FPT->getNumParams() == 0)
1727 ZeroArgCallReturnTy = FunTy->getReturnType();
1733 /// Give notes for a set of overloads.
1735 /// A companion to tryExprAsCall. In cases when the name that the programmer
1736 /// wrote was an overloaded function, we may be able to make some guesses about
1737 /// plausible overloads based on their return types; such guesses can be handed
1738 /// off to this method to be emitted as notes.
1740 /// \param Overloads - The overloads to note.
1741 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1742 /// -fshow-overloads=best, this is the location to attach to the note about too
1743 /// many candidates. Typically this will be the location of the original
1744 /// ill-formed expression.
1745 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1746 const SourceLocation FinalNoteLoc) {
1747 int ShownOverloads = 0;
1748 int SuppressedOverloads = 0;
1749 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1750 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1751 // FIXME: Magic number for max shown overloads stolen from
1752 // OverloadCandidateSet::NoteCandidates.
1753 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1754 ++SuppressedOverloads;
1758 NamedDecl *Fn = (*It)->getUnderlyingDecl();
1759 // Don't print overloads for non-default multiversioned functions.
1760 if (const auto *FD = Fn->getAsFunction()) {
1761 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
1762 !FD->getAttr<TargetAttr>()->isDefaultVersion())
1765 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
1769 if (SuppressedOverloads)
1770 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1771 << SuppressedOverloads;
1774 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
1775 const UnresolvedSetImpl &Overloads,
1776 bool (*IsPlausibleResult)(QualType)) {
1777 if (!IsPlausibleResult)
1778 return noteOverloads(S, Overloads, Loc);
1780 UnresolvedSet<2> PlausibleOverloads;
1781 for (OverloadExpr::decls_iterator It = Overloads.begin(),
1782 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1783 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
1784 QualType OverloadResultTy = OverloadDecl->getReturnType();
1785 if (IsPlausibleResult(OverloadResultTy))
1786 PlausibleOverloads.addDecl(It.getDecl());
1788 noteOverloads(S, PlausibleOverloads, Loc);
1791 /// Determine whether the given expression can be called by just
1792 /// putting parentheses after it. Notably, expressions with unary
1793 /// operators can't be because the unary operator will start parsing
1794 /// outside the call.
1795 static bool IsCallableWithAppend(Expr *E) {
1796 E = E->IgnoreImplicit();
1797 return (!isa<CStyleCastExpr>(E) &&
1798 !isa<UnaryOperator>(E) &&
1799 !isa<BinaryOperator>(E) &&
1800 !isa<CXXOperatorCallExpr>(E));
1803 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
1804 if (const auto *UO = dyn_cast<UnaryOperator>(E))
1805 E = UO->getSubExpr();
1807 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
1808 if (ULE->getNumDecls() == 0)
1811 const NamedDecl *ND = *ULE->decls_begin();
1812 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1813 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
1818 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
1820 bool (*IsPlausibleResult)(QualType)) {
1821 SourceLocation Loc = E.get()->getExprLoc();
1822 SourceRange Range = E.get()->getSourceRange();
1824 QualType ZeroArgCallTy;
1825 UnresolvedSet<4> Overloads;
1826 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
1827 !ZeroArgCallTy.isNull() &&
1828 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
1829 // At this point, we know E is potentially callable with 0
1830 // arguments and that it returns something of a reasonable type,
1831 // so we can emit a fixit and carry on pretending that E was
1832 // actually a CallExpr.
1833 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
1834 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1835 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
1836 << (IsCallableWithAppend(E.get())
1837 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
1840 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1842 // FIXME: Try this before emitting the fixit, and suppress diagnostics
1844 E = ActOnCallExpr(nullptr, E.get(), Range.getEnd(), None,
1845 Range.getEnd().getLocWithOffset(1));
1849 if (!ForceComplain) return false;
1851 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
1852 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
1854 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
1859 IdentifierInfo *Sema::getSuperIdentifier() const {
1861 Ident_super = &Context.Idents.get("super");
1865 IdentifierInfo *Sema::getFloat128Identifier() const {
1866 if (!Ident___float128)
1867 Ident___float128 = &Context.Idents.get("__float128");
1868 return Ident___float128;
1871 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
1872 CapturedRegionKind K) {
1873 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
1874 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
1875 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
1876 CSI->ReturnType = Context.VoidTy;
1877 FunctionScopes.push_back(CSI);
1880 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
1881 if (FunctionScopes.empty())
1884 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
1887 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
1888 Sema::getMismatchingDeleteExpressions() const {
1892 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
1895 llvm::SmallVector<StringRef, 1> Exts;
1896 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1897 auto CanT = T.getCanonicalType().getTypePtr();
1898 for (auto &I : Exts)
1899 OpenCLTypeExtMap[CanT].insert(I.str());
1902 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
1903 llvm::SmallVector<StringRef, 1> Exts;
1904 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
1907 for (auto &I : Exts)
1908 OpenCLDeclExtMap[FD].insert(I.str());
1911 void Sema::setCurrentOpenCLExtensionForType(QualType T) {
1912 if (CurrOpenCLExtension.empty())
1914 setOpenCLExtensionForType(T, CurrOpenCLExtension);
1917 void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
1918 if (CurrOpenCLExtension.empty())
1920 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
1923 std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
1924 if (!OpenCLDeclExtMap.empty())
1925 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
1930 std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
1931 if (!OpenCLTypeExtMap.empty())
1932 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
1937 template <typename T, typename MapT>
1938 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
1939 std::string ExtensionNames = "";
1940 auto Loc = Map.find(FDT);
1942 for (auto const& I : Loc->second) {
1943 ExtensionNames += I;
1944 ExtensionNames += " ";
1946 ExtensionNames.pop_back();
1948 return ExtensionNames;
1951 bool Sema::isOpenCLDisabledDecl(Decl *FD) {
1952 auto Loc = OpenCLDeclExtMap.find(FD);
1953 if (Loc == OpenCLDeclExtMap.end())
1955 for (auto &I : Loc->second) {
1956 if (!getOpenCLOptions().isEnabled(I))
1962 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
1963 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
1964 DiagInfoT DiagInfo, MapT &Map,
1966 SourceRange SrcRange) {
1967 auto Loc = Map.find(D);
1968 if (Loc == Map.end())
1970 bool Disabled = false;
1971 for (auto &I : Loc->second) {
1972 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
1973 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
1981 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
1982 // Check extensions for declared types.
1983 Decl *Decl = nullptr;
1984 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
1985 Decl = TypedefT->getDecl();
1986 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
1987 Decl = TagT->getDecl();
1988 auto Loc = DS.getTypeSpecTypeLoc();
1990 // Check extensions for vector types.
1991 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
1992 if (QT->isExtVectorType()) {
1993 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
1994 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
1997 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2000 // Check extensions for builtin types.
2001 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2002 QT, OpenCLTypeExtMap);
2005 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2006 IdentifierInfo *FnName = D.getIdentifier();
2007 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2008 OpenCLDeclExtMap, 1, D.getSourceRange());