1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This file implements the actions class which performs semantic analysis and
10 // builds an AST out of a parse stream.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTDiagnostic.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclFriend.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/ExprCXX.h"
21 #include "clang/AST/PrettyDeclStackTrace.h"
22 #include "clang/AST/StmtCXX.h"
23 #include "clang/Basic/DiagnosticOptions.h"
24 #include "clang/Basic/PartialDiagnostic.h"
25 #include "clang/Basic/Stack.h"
26 #include "clang/Basic/TargetInfo.h"
27 #include "clang/Lex/HeaderSearch.h"
28 #include "clang/Lex/Preprocessor.h"
29 #include "clang/Sema/CXXFieldCollector.h"
30 #include "clang/Sema/DelayedDiagnostic.h"
31 #include "clang/Sema/ExternalSemaSource.h"
32 #include "clang/Sema/Initialization.h"
33 #include "clang/Sema/MultiplexExternalSemaSource.h"
34 #include "clang/Sema/ObjCMethodList.h"
35 #include "clang/Sema/Scope.h"
36 #include "clang/Sema/ScopeInfo.h"
37 #include "clang/Sema/SemaConsumer.h"
38 #include "clang/Sema/SemaInternal.h"
39 #include "clang/Sema/TemplateDeduction.h"
40 #include "clang/Sema/TemplateInstCallback.h"
41 #include "clang/Sema/TypoCorrection.h"
42 #include "llvm/ADT/DenseMap.h"
43 #include "llvm/ADT/SmallSet.h"
44 #include "llvm/Support/TimeProfiler.h"
46 using namespace clang;
49 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
50 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
53 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
55 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
56 const Preprocessor &PP) {
57 PrintingPolicy Policy = Context.getPrintingPolicy();
58 // In diagnostics, we print _Bool as bool if the latter is defined as the
60 Policy.Bool = Context.getLangOpts().Bool;
62 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
63 Policy.Bool = BoolMacro->isObjectLike() &&
64 BoolMacro->getNumTokens() == 1 &&
65 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
72 void Sema::ActOnTranslationUnitScope(Scope *S) {
74 PushDeclContext(S, Context.getTranslationUnitDecl());
80 class SemaPPCallbacks : public PPCallbacks {
82 llvm::SmallVector<SourceLocation, 8> IncludeStack;
85 void set(Sema &S) { this->S = &S; }
87 void reset() { S = nullptr; }
89 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
90 SrcMgr::CharacteristicKind FileType,
91 FileID PrevFID) override {
96 SourceManager &SM = S->getSourceManager();
97 SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
98 if (IncludeLoc.isValid()) {
99 if (llvm::timeTraceProfilerEnabled()) {
100 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
101 llvm::timeTraceProfilerBegin(
102 "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
105 IncludeStack.push_back(IncludeLoc);
106 S->DiagnoseNonDefaultPragmaPack(
107 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
112 if (!IncludeStack.empty()) {
113 if (llvm::timeTraceProfilerEnabled())
114 llvm::timeTraceProfilerEnd();
116 S->DiagnoseNonDefaultPragmaPack(
117 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
118 IncludeStack.pop_back_val());
127 } // end namespace sema
128 } // end namespace clang
130 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
131 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
132 : ExternalSource(nullptr), isMultiplexExternalSource(false),
133 FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
134 Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
135 SourceMgr(PP.getSourceManager()), CollectStats(false),
136 CodeCompleter(CodeCompleter), CurContext(nullptr),
137 OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
138 MSPointerToMemberRepresentationMethod(
139 LangOpts.getMSPointerToMemberRepresentationMethod()),
140 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
141 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
142 CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
143 PragmaAttributeCurrentTargetDecl(nullptr),
144 IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
145 LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
146 StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
147 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
148 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
149 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
150 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
151 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
152 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
153 TUKind(TUKind), NumSFINAEErrors(0),
154 FullyCheckedComparisonCategories(
155 static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
156 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
157 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
158 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
159 TyposCorrected(0), AnalysisWarnings(*this),
160 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
161 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
163 isConstantEvaluatedOverride = false;
165 LoadedExternalKnownNamespaces = false;
166 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
167 NSNumberLiteralMethods[I] = nullptr;
169 if (getLangOpts().ObjC)
170 NSAPIObj.reset(new NSAPI(Context));
172 if (getLangOpts().CPlusPlus)
173 FieldCollector.reset(new CXXFieldCollector());
175 // Tell diagnostics how to render things from the AST library.
176 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
178 ExprEvalContexts.emplace_back(
179 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
180 nullptr, ExpressionEvaluationContextRecord::EK_Other);
182 // Initialization of data sharing attributes stack for OpenMP
183 InitDataSharingAttributesStack();
185 std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
186 std::make_unique<sema::SemaPPCallbacks>();
187 SemaPPCallbackHandler = Callbacks.get();
188 PP.addPPCallbacks(std::move(Callbacks));
189 SemaPPCallbackHandler->set(*this);
192 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
193 DeclarationName DN = &Context.Idents.get(Name);
194 if (IdResolver.begin(DN) == IdResolver.end())
195 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
198 void Sema::Initialize() {
199 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
200 SC->InitializeSema(*this);
202 // Tell the external Sema source about this Sema object.
203 if (ExternalSemaSource *ExternalSema
204 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
205 ExternalSema->InitializeSema(*this);
207 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
208 // will not be able to merge any duplicate __va_list_tag decls correctly.
209 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
214 // Initialize predefined 128-bit integer types, if needed.
215 if (Context.getTargetInfo().hasInt128Type()) {
216 // If either of the 128-bit integer types are unavailable to name lookup,
218 DeclarationName Int128 = &Context.Idents.get("__int128_t");
219 if (IdResolver.begin(Int128) == IdResolver.end())
220 PushOnScopeChains(Context.getInt128Decl(), TUScope);
222 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
223 if (IdResolver.begin(UInt128) == IdResolver.end())
224 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
228 // Initialize predefined Objective-C types:
229 if (getLangOpts().ObjC) {
230 // If 'SEL' does not yet refer to any declarations, make it refer to the
232 DeclarationName SEL = &Context.Idents.get("SEL");
233 if (IdResolver.begin(SEL) == IdResolver.end())
234 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
236 // If 'id' does not yet refer to any declarations, make it refer to the
238 DeclarationName Id = &Context.Idents.get("id");
239 if (IdResolver.begin(Id) == IdResolver.end())
240 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
242 // Create the built-in typedef for 'Class'.
243 DeclarationName Class = &Context.Idents.get("Class");
244 if (IdResolver.begin(Class) == IdResolver.end())
245 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
247 // Create the built-in forward declaratino for 'Protocol'.
248 DeclarationName Protocol = &Context.Idents.get("Protocol");
249 if (IdResolver.begin(Protocol) == IdResolver.end())
250 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
253 // Create the internal type for the *StringMakeConstantString builtins.
254 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
255 if (IdResolver.begin(ConstantString) == IdResolver.end())
256 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
258 // Initialize Microsoft "predefined C++ types".
259 if (getLangOpts().MSVCCompat) {
260 if (getLangOpts().CPlusPlus &&
261 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
262 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
265 addImplicitTypedef("size_t", Context.getSizeType());
268 // Initialize predefined OpenCL types and supported extensions and (optional)
270 if (getLangOpts().OpenCL) {
271 getOpenCLOptions().addSupport(
272 Context.getTargetInfo().getSupportedOpenCLOpts());
273 getOpenCLOptions().enableSupportedCore(getLangOpts());
274 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
275 addImplicitTypedef("event_t", Context.OCLEventTy);
276 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
277 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
278 addImplicitTypedef("queue_t", Context.OCLQueueTy);
279 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
280 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
281 addImplicitTypedef("atomic_uint",
282 Context.getAtomicType(Context.UnsignedIntTy));
283 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
284 addImplicitTypedef("atomic_long", AtomicLongT);
285 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
286 addImplicitTypedef("atomic_ulong", AtomicULongT);
287 addImplicitTypedef("atomic_float",
288 Context.getAtomicType(Context.FloatTy));
289 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
290 addImplicitTypedef("atomic_double", AtomicDoubleT);
291 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
292 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
293 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
294 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
295 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
296 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
297 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
298 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
299 addImplicitTypedef("atomic_size_t", AtomicSizeT);
300 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
301 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
303 // OpenCL v2.0 s6.13.11.6:
304 // - The atomic_long and atomic_ulong types are supported if the
305 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
306 // extensions are supported.
307 // - The atomic_double type is only supported if double precision
308 // is supported and the cl_khr_int64_base_atomics and
309 // cl_khr_int64_extended_atomics extensions are supported.
310 // - If the device address space is 64-bits, the data types
311 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
312 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
313 // cl_khr_int64_extended_atomics extensions are supported.
314 std::vector<QualType> Atomic64BitTypes;
315 Atomic64BitTypes.push_back(AtomicLongT);
316 Atomic64BitTypes.push_back(AtomicULongT);
317 Atomic64BitTypes.push_back(AtomicDoubleT);
318 if (Context.getTypeSize(AtomicSizeT) == 64) {
319 Atomic64BitTypes.push_back(AtomicSizeT);
320 Atomic64BitTypes.push_back(AtomicIntPtrT);
321 Atomic64BitTypes.push_back(AtomicUIntPtrT);
322 Atomic64BitTypes.push_back(AtomicPtrDiffT);
324 for (auto &I : Atomic64BitTypes)
325 setOpenCLExtensionForType(I,
326 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
328 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
331 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
333 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
334 setOpenCLExtensionForType(Context.Id, Ext);
335 #include "clang/Basic/OpenCLImageTypes.def"
336 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
337 addImplicitTypedef(#ExtType, Context.Id##Ty); \
338 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
339 #include "clang/Basic/OpenCLExtensionTypes.def"
342 if (Context.getTargetInfo().hasAArch64SVETypes()) {
343 #define SVE_TYPE(Name, Id, SingletonId) \
344 addImplicitTypedef(Name, Context.SingletonId);
345 #include "clang/Basic/AArch64SVEACLETypes.def"
348 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
349 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
350 if (IdResolver.begin(MSVaList) == IdResolver.end())
351 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
354 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
355 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
356 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
360 if (VisContext) FreeVisContext();
362 // Kill all the active scopes.
363 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
366 // Tell the SemaConsumer to forget about us; we're going out of scope.
367 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
370 // Detach from the external Sema source.
371 if (ExternalSemaSource *ExternalSema
372 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
373 ExternalSema->ForgetSema();
375 // If Sema's ExternalSource is the multiplexer - we own it.
376 if (isMultiplexExternalSource)
377 delete ExternalSource;
379 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
381 // Destroys data sharing attributes stack for OpenMP
382 DestroyDataSharingAttributesStack();
384 // Detach from the PP callback handler which outlives Sema since it's owned
385 // by the preprocessor.
386 SemaPPCallbackHandler->reset();
389 void Sema::warnStackExhausted(SourceLocation Loc) {
390 // Only warn about this once.
391 if (!WarnedStackExhausted) {
392 Diag(Loc, diag::warn_stack_exhausted);
393 WarnedStackExhausted = true;
397 void Sema::runWithSufficientStackSpace(SourceLocation Loc,
398 llvm::function_ref<void()> Fn) {
399 clang::runWithSufficientStackSpace([&] { warnStackExhausted(Loc); }, Fn);
402 /// makeUnavailableInSystemHeader - There is an error in the current
403 /// context. If we're still in a system header, and we can plausibly
404 /// make the relevant declaration unavailable instead of erroring, do
405 /// so and return true.
406 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
407 UnavailableAttr::ImplicitReason reason) {
408 // If we're not in a function, it's an error.
409 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
410 if (!fn) return false;
412 // If we're in template instantiation, it's an error.
413 if (inTemplateInstantiation())
416 // If that function's not in a system header, it's an error.
417 if (!Context.getSourceManager().isInSystemHeader(loc))
420 // If the function is already unavailable, it's not an error.
421 if (fn->hasAttr<UnavailableAttr>()) return true;
423 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
427 ASTMutationListener *Sema::getASTMutationListener() const {
428 return getASTConsumer().GetASTMutationListener();
431 ///Registers an external source. If an external source already exists,
432 /// creates a multiplex external source and appends to it.
434 ///\param[in] E - A non-null external sema source.
436 void Sema::addExternalSource(ExternalSemaSource *E) {
437 assert(E && "Cannot use with NULL ptr");
439 if (!ExternalSource) {
444 if (isMultiplexExternalSource)
445 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
447 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
448 isMultiplexExternalSource = true;
452 /// Print out statistics about the semantic analysis.
453 void Sema::PrintStats() const {
454 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
455 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
457 BumpAlloc.PrintStats();
458 AnalysisWarnings.PrintStats();
461 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
463 SourceLocation Loc) {
464 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
465 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
468 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
469 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
472 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
475 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
476 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
479 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
480 if (!getLangOpts().CPlusPlus11)
483 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
485 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
488 // If it is a macro from system header, and if the macro name is not "NULL",
490 SourceLocation MaybeMacroLoc = E->getBeginLoc();
491 if (Diags.getSuppressSystemWarnings() &&
492 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
493 !findMacroSpelling(MaybeMacroLoc, "NULL"))
496 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
497 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
500 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
501 /// If there is already an implicit cast, merge into the existing one.
502 /// The result is of the given category.
503 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
504 CastKind Kind, ExprValueKind VK,
505 const CXXCastPath *BasePath,
506 CheckedConversionKind CCK) {
508 if (VK == VK_RValue && !E->isRValue()) {
511 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
514 case CK_LValueToRValue:
515 case CK_ArrayToPointerDecay:
516 case CK_FunctionToPointerDecay:
518 case CK_NonAtomicToAtomic:
522 assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
523 "can't cast rvalue to lvalue");
526 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
527 diagnoseZeroToNullptrConversion(Kind, E);
529 QualType ExprTy = Context.getCanonicalType(E->getType());
530 QualType TypeTy = Context.getCanonicalType(Ty);
532 if (ExprTy == TypeTy)
535 // C++1z [conv.array]: The temporary materialization conversion is applied.
536 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
537 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
538 E->getValueKind() == VK_RValue) {
539 // The temporary is an lvalue in C++98 and an xvalue otherwise.
540 ExprResult Materialized = CreateMaterializeTemporaryExpr(
541 E->getType(), E, !getLangOpts().CPlusPlus11);
542 if (Materialized.isInvalid())
544 E = Materialized.get();
547 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
548 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
549 ImpCast->setType(Ty);
550 ImpCast->setValueKind(VK);
555 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
558 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
559 /// to the conversion from scalar type ScalarTy to the Boolean type.
560 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
561 switch (ScalarTy->getScalarTypeKind()) {
562 case Type::STK_Bool: return CK_NoOp;
563 case Type::STK_CPointer: return CK_PointerToBoolean;
564 case Type::STK_BlockPointer: return CK_PointerToBoolean;
565 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
566 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
567 case Type::STK_Integral: return CK_IntegralToBoolean;
568 case Type::STK_Floating: return CK_FloatingToBoolean;
569 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
570 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
571 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
573 llvm_unreachable("unknown scalar type kind");
576 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
577 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
578 if (D->getMostRecentDecl()->isUsed())
581 if (D->isExternallyVisible())
584 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
585 // If this is a function template and none of its specializations is used,
587 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
588 for (const auto *Spec : Template->specializations())
589 if (ShouldRemoveFromUnused(SemaRef, Spec))
592 // UnusedFileScopedDecls stores the first declaration.
593 // The declaration may have become definition so check again.
594 const FunctionDecl *DeclToCheck;
595 if (FD->hasBody(DeclToCheck))
596 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
598 // Later redecls may add new information resulting in not having to warn,
600 DeclToCheck = FD->getMostRecentDecl();
601 if (DeclToCheck != FD)
602 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
605 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
606 // If a variable usable in constant expressions is referenced,
607 // don't warn if it isn't used: if the value of a variable is required
608 // for the computation of a constant expression, it doesn't make sense to
609 // warn even if the variable isn't odr-used. (isReferenced doesn't
610 // precisely reflect that, but it's a decent approximation.)
611 if (VD->isReferenced() &&
612 VD->mightBeUsableInConstantExpressions(SemaRef->Context))
615 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
616 // If this is a variable template and none of its specializations is used,
618 for (const auto *Spec : Template->specializations())
619 if (ShouldRemoveFromUnused(SemaRef, Spec))
622 // UnusedFileScopedDecls stores the first declaration.
623 // The declaration may have become definition so check again.
624 const VarDecl *DeclToCheck = VD->getDefinition();
626 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
628 // Later redecls may add new information resulting in not having to warn,
630 DeclToCheck = VD->getMostRecentDecl();
631 if (DeclToCheck != VD)
632 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
638 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
639 if (auto *FD = dyn_cast<FunctionDecl>(ND))
640 return FD->isExternC();
641 return cast<VarDecl>(ND)->isExternC();
644 /// Determine whether ND is an external-linkage function or variable whose
645 /// type has no linkage.
646 bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
647 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
648 // because we also want to catch the case where its type has VisibleNoLinkage,
649 // which does not affect the linkage of VD.
650 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
651 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
652 !isFunctionOrVarDeclExternC(VD);
655 /// Obtains a sorted list of functions and variables that are undefined but
657 void Sema::getUndefinedButUsed(
658 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
659 for (const auto &UndefinedUse : UndefinedButUsed) {
660 NamedDecl *ND = UndefinedUse.first;
662 // Ignore attributes that have become invalid.
663 if (ND->isInvalidDecl()) continue;
665 // __attribute__((weakref)) is basically a definition.
666 if (ND->hasAttr<WeakRefAttr>()) continue;
668 if (isa<CXXDeductionGuideDecl>(ND))
671 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
672 // An exported function will always be emitted when defined, so even if
673 // the function is inline, it doesn't have to be emitted in this TU. An
674 // imported function implies that it has been exported somewhere else.
678 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
681 if (FD->isExternallyVisible() &&
682 !isExternalWithNoLinkageType(FD) &&
683 !FD->getMostRecentDecl()->isInlined() &&
684 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
686 if (FD->getBuiltinID())
689 auto *VD = cast<VarDecl>(ND);
690 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
692 if (VD->isExternallyVisible() &&
693 !isExternalWithNoLinkageType(VD) &&
694 !VD->getMostRecentDecl()->isInline() &&
695 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
698 // Skip VarDecls that lack formal definitions but which we know are in
699 // fact defined somewhere.
700 if (VD->isKnownToBeDefined())
704 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
708 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
709 /// or that are inline.
710 static void checkUndefinedButUsed(Sema &S) {
711 if (S.UndefinedButUsed.empty()) return;
713 // Collect all the still-undefined entities with internal linkage.
714 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
715 S.getUndefinedButUsed(Undefined);
716 if (Undefined.empty()) return;
718 for (auto Undef : Undefined) {
719 ValueDecl *VD = cast<ValueDecl>(Undef.first);
720 SourceLocation UseLoc = Undef.second;
722 if (S.isExternalWithNoLinkageType(VD)) {
723 // C++ [basic.link]p8:
724 // A type without linkage shall not be used as the type of a variable
725 // or function with external linkage unless
726 // -- the entity has C language linkage
727 // -- the entity is not odr-used or is defined in the same TU
729 // As an extension, accept this in cases where the type is externally
730 // visible, since the function or variable actually can be defined in
731 // another translation unit in that case.
732 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
733 ? diag::ext_undefined_internal_type
734 : diag::err_undefined_internal_type)
735 << isa<VarDecl>(VD) << VD;
736 } else if (!VD->isExternallyVisible()) {
737 // FIXME: We can promote this to an error. The function or variable can't
738 // be defined anywhere else, so the program must necessarily violate the
739 // one definition rule.
740 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
741 << isa<VarDecl>(VD) << VD;
742 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
744 assert(FD->getMostRecentDecl()->isInlined() &&
745 "used object requires definition but isn't inline or internal?");
746 // FIXME: This is ill-formed; we should reject.
747 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
749 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
750 "used var requires definition but isn't inline or internal?");
751 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
753 if (UseLoc.isValid())
754 S.Diag(UseLoc, diag::note_used_here);
757 S.UndefinedButUsed.clear();
760 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
764 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
765 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
766 for (auto &WeakID : WeakIDs)
767 WeakUndeclaredIdentifiers.insert(WeakID);
771 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
773 /// Returns true, if all methods and nested classes of the given
774 /// CXXRecordDecl are defined in this translation unit.
776 /// Should only be called from ActOnEndOfTranslationUnit so that all
777 /// definitions are actually read.
778 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
779 RecordCompleteMap &MNCComplete) {
780 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
781 if (Cache != MNCComplete.end())
782 return Cache->second;
783 if (!RD->isCompleteDefinition())
785 bool Complete = true;
786 for (DeclContext::decl_iterator I = RD->decls_begin(),
788 I != E && Complete; ++I) {
789 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
790 Complete = M->isDefined() || M->isDefaulted() ||
791 (M->isPure() && !isa<CXXDestructorDecl>(M));
792 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
793 // If the template function is marked as late template parsed at this
794 // point, it has not been instantiated and therefore we have not
795 // performed semantic analysis on it yet, so we cannot know if the type
796 // can be considered complete.
797 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
798 F->getTemplatedDecl()->isDefined();
799 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
800 if (R->isInjectedClassName())
802 if (R->hasDefinition())
803 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
809 MNCComplete[RD] = Complete;
813 /// Returns true, if the given CXXRecordDecl is fully defined in this
814 /// translation unit, i.e. all methods are defined or pure virtual and all
815 /// friends, friend functions and nested classes are fully defined in this
816 /// translation unit.
818 /// Should only be called from ActOnEndOfTranslationUnit so that all
819 /// definitions are actually read.
820 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
821 RecordCompleteMap &RecordsComplete,
822 RecordCompleteMap &MNCComplete) {
823 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
824 if (Cache != RecordsComplete.end())
825 return Cache->second;
826 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
827 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
828 E = RD->friend_end();
829 I != E && Complete; ++I) {
830 // Check if friend classes and methods are complete.
831 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
832 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
833 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
834 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
838 // Friend functions are available through the NamedDecl of FriendDecl.
839 if (const FunctionDecl *FD =
840 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
841 Complete = FD->isDefined();
843 // This is a template friend, give up.
847 RecordsComplete[RD] = Complete;
851 void Sema::emitAndClearUnusedLocalTypedefWarnings() {
853 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
854 UnusedLocalTypedefNameCandidates);
855 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
856 if (TD->isReferenced())
858 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
859 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
861 UnusedLocalTypedefNameCandidates.clear();
864 /// This is called before the very first declaration in the translation unit
865 /// is parsed. Note that the ASTContext may have already injected some
867 void Sema::ActOnStartOfTranslationUnit() {
868 if (getLangOpts().ModulesTS &&
869 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
870 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
871 // We start in an implied global module fragment.
872 SourceLocation StartOfTU =
873 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
874 ActOnGlobalModuleFragmentDecl(StartOfTU);
875 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
879 void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
880 // No explicit actions are required at the end of the global module fragment.
881 if (Kind == TUFragmentKind::Global)
884 // Transfer late parsed template instantiations over to the pending template
885 // instantiation list. During normal compilation, the late template parser
886 // will be installed and instantiating these templates will succeed.
888 // If we are building a TU prefix for serialization, it is also safe to
889 // transfer these over, even though they are not parsed. The end of the TU
890 // should be outside of any eager template instantiation scope, so when this
891 // AST is deserialized, these templates will not be parsed until the end of
893 PendingInstantiations.insert(PendingInstantiations.end(),
894 LateParsedInstantiations.begin(),
895 LateParsedInstantiations.end());
896 LateParsedInstantiations.clear();
898 // If DefinedUsedVTables ends up marking any virtual member functions it
899 // might lead to more pending template instantiations, which we then need
903 // C++: Perform implicit template instantiations.
905 // FIXME: When we perform these implicit instantiations, we do not
906 // carefully keep track of the point of instantiation (C++ [temp.point]).
907 // This means that name lookup that occurs within the template
908 // instantiation will always happen at the end of the translation unit,
909 // so it will find some names that are not required to be found. This is
910 // valid, but we could do better by diagnosing if an instantiation uses a
911 // name that was not visible at its first point of instantiation.
912 if (ExternalSource) {
913 // Load pending instantiations from the external source.
914 SmallVector<PendingImplicitInstantiation, 4> Pending;
915 ExternalSource->ReadPendingInstantiations(Pending);
916 for (auto PII : Pending)
917 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
918 Func->setInstantiationIsPending(true);
919 PendingInstantiations.insert(PendingInstantiations.begin(),
920 Pending.begin(), Pending.end());
924 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
926 PerformPendingInstantiations();
929 // Finalize analysis of OpenMP-specific constructs.
931 finalizeOpenMPDelayedAnalysis();
933 assert(LateParsedInstantiations.empty() &&
934 "end of TU template instantiation should not create more "
935 "late-parsed templates");
937 // Report diagnostics for uncorrected delayed typos. Ideally all of them
938 // should have been corrected by that time, but it is very hard to cover all
939 // cases in practice.
940 for (const auto &Typo : DelayedTypos) {
941 // We pass an empty TypoCorrection to indicate no correction was performed.
942 Typo.second.DiagHandler(TypoCorrection());
944 DelayedTypos.clear();
947 /// ActOnEndOfTranslationUnit - This is called at the very end of the
948 /// translation unit when EOF is reached and all but the top-level scope is
950 void Sema::ActOnEndOfTranslationUnit() {
951 assert(DelayedDiagnostics.getCurrentPool() == nullptr
952 && "reached end of translation unit with a pool attached?");
954 // If code completion is enabled, don't perform any end-of-translation-unit
956 if (PP.isCodeCompletionEnabled())
959 // Complete translation units and modules define vtables and perform implicit
960 // instantiations. PCH files do not.
961 if (TUKind != TU_Prefix) {
962 DiagnoseUseOfUnimplementedSelectors();
964 ActOnEndOfTranslationUnitFragment(
965 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
966 Module::PrivateModuleFragment
967 ? TUFragmentKind::Private
968 : TUFragmentKind::Normal);
970 if (LateTemplateParserCleanup)
971 LateTemplateParserCleanup(OpaqueParser);
973 CheckDelayedMemberExceptionSpecs();
975 // If we are building a TU prefix for serialization, it is safe to transfer
976 // these over, even though they are not parsed. The end of the TU should be
977 // outside of any eager template instantiation scope, so when this AST is
978 // deserialized, these templates will not be parsed until the end of the
980 PendingInstantiations.insert(PendingInstantiations.end(),
981 LateParsedInstantiations.begin(),
982 LateParsedInstantiations.end());
983 LateParsedInstantiations.clear();
986 DiagnoseUnterminatedPragmaPack();
987 DiagnoseUnterminatedPragmaAttribute();
989 // All delayed member exception specs should be checked or we end up accepting
990 // incompatible declarations.
991 assert(DelayedOverridingExceptionSpecChecks.empty());
992 assert(DelayedEquivalentExceptionSpecChecks.empty());
994 // All dllexport classes should have been processed already.
995 assert(DelayedDllExportClasses.empty());
996 assert(DelayedDllExportMemberFunctions.empty());
998 // Remove file scoped decls that turned out to be used.
999 UnusedFileScopedDecls.erase(
1000 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
1001 UnusedFileScopedDecls.end(),
1002 [this](const DeclaratorDecl *DD) {
1003 return ShouldRemoveFromUnused(this, DD);
1005 UnusedFileScopedDecls.end());
1007 if (TUKind == TU_Prefix) {
1008 // Translation unit prefixes don't need any of the checking below.
1009 if (!PP.isIncrementalProcessingEnabled())
1014 // Check for #pragma weak identifiers that were never declared
1015 LoadExternalWeakUndeclaredIdentifiers();
1016 for (auto WeakID : WeakUndeclaredIdentifiers) {
1017 if (WeakID.second.getUsed())
1020 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
1021 LookupOrdinaryName);
1022 if (PrevDecl != nullptr &&
1023 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
1024 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
1025 << "'weak'" << ExpectedVariableOrFunction;
1027 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
1031 if (LangOpts.CPlusPlus11 &&
1032 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1033 CheckDelegatingCtorCycles();
1035 if (!Diags.hasErrorOccurred()) {
1037 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1038 checkUndefinedButUsed(*this);
1041 // A global-module-fragment is only permitted within a module unit.
1042 bool DiagnosedMissingModuleDeclaration = false;
1043 if (!ModuleScopes.empty() &&
1044 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1045 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1046 Diag(ModuleScopes.back().BeginLoc,
1047 diag::err_module_declaration_missing_after_global_module_introducer);
1048 DiagnosedMissingModuleDeclaration = true;
1051 if (TUKind == TU_Module) {
1052 // If we are building a module interface unit, we need to have seen the
1053 // module declaration by now.
1054 if (getLangOpts().getCompilingModule() ==
1055 LangOptions::CMK_ModuleInterface &&
1056 (ModuleScopes.empty() ||
1057 !ModuleScopes.back().Module->isModulePurview()) &&
1058 !DiagnosedMissingModuleDeclaration) {
1059 // FIXME: Make a better guess as to where to put the module declaration.
1060 Diag(getSourceManager().getLocForStartOfFile(
1061 getSourceManager().getMainFileID()),
1062 diag::err_module_declaration_missing);
1065 // If we are building a module, resolve all of the exported declarations
1067 if (Module *CurrentModule = PP.getCurrentModule()) {
1068 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
1070 SmallVector<Module *, 2> Stack;
1071 Stack.push_back(CurrentModule);
1072 while (!Stack.empty()) {
1073 Module *Mod = Stack.pop_back_val();
1075 // Resolve the exported declarations and conflicts.
1076 // FIXME: Actually complain, once we figure out how to teach the
1077 // diagnostic client to deal with complaints in the module map at this
1079 ModMap.resolveExports(Mod, /*Complain=*/false);
1080 ModMap.resolveUses(Mod, /*Complain=*/false);
1081 ModMap.resolveConflicts(Mod, /*Complain=*/false);
1083 // Queue the submodules, so their exports will also be resolved.
1084 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1088 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1089 // modules when they are built, not every time they are used.
1090 emitAndClearUnusedLocalTypedefWarnings();
1094 // A declaration of an identifier for an object that has file
1095 // scope without an initializer, and without a storage-class
1096 // specifier or with the storage-class specifier static,
1097 // constitutes a tentative definition. If a translation unit
1098 // contains one or more tentative definitions for an identifier,
1099 // and the translation unit contains no external definition for
1100 // that identifier, then the behavior is exactly as if the
1101 // translation unit contains a file scope declaration of that
1102 // identifier, with the composite type as of the end of the
1103 // translation unit, with an initializer equal to 0.
1104 llvm::SmallSet<VarDecl *, 32> Seen;
1105 for (TentativeDefinitionsType::iterator
1106 T = TentativeDefinitions.begin(ExternalSource),
1107 TEnd = TentativeDefinitions.end();
1109 VarDecl *VD = (*T)->getActingDefinition();
1111 // If the tentative definition was completed, getActingDefinition() returns
1112 // null. If we've already seen this variable before, insert()'s second
1113 // return value is false.
1114 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1117 if (const IncompleteArrayType *ArrayT
1118 = Context.getAsIncompleteArrayType(VD->getType())) {
1119 // Set the length of the array to 1 (C99 6.9.2p5).
1120 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1121 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1122 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One,
1123 nullptr, ArrayType::Normal, 0);
1125 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1126 diag::err_tentative_def_incomplete_type))
1127 VD->setInvalidDecl();
1129 // No initialization is performed for a tentative definition.
1130 CheckCompleteVariableDeclaration(VD);
1132 // Notify the consumer that we've completed a tentative definition.
1133 if (!VD->isInvalidDecl())
1134 Consumer.CompleteTentativeDefinition(VD);
1137 // If there were errors, disable 'unused' warnings since they will mostly be
1138 // noise. Don't warn for a use from a module: either we should warn on all
1139 // file-scope declarations in modules or not at all, but whether the
1140 // declaration is used is immaterial.
1141 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1142 // Output warning for unused file scoped decls.
1143 for (UnusedFileScopedDeclsType::iterator
1144 I = UnusedFileScopedDecls.begin(ExternalSource),
1145 E = UnusedFileScopedDecls.end(); I != E; ++I) {
1146 if (ShouldRemoveFromUnused(this, *I))
1149 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1150 const FunctionDecl *DiagD;
1151 if (!FD->hasBody(DiagD))
1153 if (DiagD->isDeleted())
1154 continue; // Deleted functions are supposed to be unused.
1155 if (DiagD->isReferenced()) {
1156 if (isa<CXXMethodDecl>(DiagD))
1157 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1158 << DiagD->getDeclName();
1160 if (FD->getStorageClass() == SC_Static &&
1161 !FD->isInlineSpecified() &&
1162 !SourceMgr.isInMainFile(
1163 SourceMgr.getExpansionLoc(FD->getLocation())))
1164 Diag(DiagD->getLocation(),
1165 diag::warn_unneeded_static_internal_decl)
1166 << DiagD->getDeclName();
1168 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1169 << /*function*/0 << DiagD->getDeclName();
1172 if (FD->getDescribedFunctionTemplate())
1173 Diag(DiagD->getLocation(), diag::warn_unused_template)
1174 << /*function*/0 << DiagD->getDeclName();
1176 Diag(DiagD->getLocation(),
1177 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1178 : diag::warn_unused_function)
1179 << DiagD->getDeclName();
1182 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1184 DiagD = cast<VarDecl>(*I);
1185 if (DiagD->isReferenced()) {
1186 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1187 << /*variable*/1 << DiagD->getDeclName();
1188 } else if (DiagD->getType().isConstQualified()) {
1189 const SourceManager &SM = SourceMgr;
1190 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1191 !PP.getLangOpts().IsHeaderFile)
1192 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1193 << DiagD->getDeclName();
1195 if (DiagD->getDescribedVarTemplate())
1196 Diag(DiagD->getLocation(), diag::warn_unused_template)
1197 << /*variable*/1 << DiagD->getDeclName();
1199 Diag(DiagD->getLocation(), diag::warn_unused_variable)
1200 << DiagD->getDeclName();
1205 emitAndClearUnusedLocalTypedefWarnings();
1208 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1209 // FIXME: Load additional unused private field candidates from the external
1211 RecordCompleteMap RecordsComplete;
1212 RecordCompleteMap MNCComplete;
1213 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1214 E = UnusedPrivateFields.end(); I != E; ++I) {
1215 const NamedDecl *D = *I;
1216 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1217 if (RD && !RD->isUnion() &&
1218 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1219 Diag(D->getLocation(), diag::warn_unused_private_field)
1220 << D->getDeclName();
1225 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1227 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1228 for (const auto &DeletedFieldInfo : DeleteExprs) {
1229 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1230 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1231 DeleteExprLoc.second);
1236 // Check we've noticed that we're no longer parsing the initializer for every
1237 // variable. If we miss cases, then at best we have a performance issue and
1238 // at worst a rejects-valid bug.
1239 assert(ParsingInitForAutoVars.empty() &&
1240 "Didn't unmark var as having its initializer parsed");
1242 if (!PP.isIncrementalProcessingEnabled())
1247 //===----------------------------------------------------------------------===//
1248 // Helper functions.
1249 //===----------------------------------------------------------------------===//
1251 DeclContext *Sema::getFunctionLevelDeclContext() {
1252 DeclContext *DC = CurContext;
1255 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1256 DC = DC->getParent();
1257 } else if (isa<CXXMethodDecl>(DC) &&
1258 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1259 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1260 DC = DC->getParent()->getParent();
1268 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1269 /// to the function decl for the function being parsed. If we're currently
1270 /// in a 'block', this returns the containing context.
1271 FunctionDecl *Sema::getCurFunctionDecl() {
1272 DeclContext *DC = getFunctionLevelDeclContext();
1273 return dyn_cast<FunctionDecl>(DC);
1276 ObjCMethodDecl *Sema::getCurMethodDecl() {
1277 DeclContext *DC = getFunctionLevelDeclContext();
1278 while (isa<RecordDecl>(DC))
1279 DC = DC->getParent();
1280 return dyn_cast<ObjCMethodDecl>(DC);
1283 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
1284 DeclContext *DC = getFunctionLevelDeclContext();
1285 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1286 return cast<NamedDecl>(DC);
1290 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1291 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1292 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1293 // been made more painfully obvious by the refactor that introduced this
1294 // function, but it is possible that the incoming argument can be
1295 // eliminated. If it truly cannot be (for example, there is some reentrancy
1296 // issue I am not seeing yet), then there should at least be a clarifying
1297 // comment somewhere.
1298 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
1299 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1300 Diags.getCurrentDiagID())) {
1301 case DiagnosticIDs::SFINAE_Report:
1302 // We'll report the diagnostic below.
1305 case DiagnosticIDs::SFINAE_SubstitutionFailure:
1306 // Count this failure so that we know that template argument deduction
1310 // Make a copy of this suppressed diagnostic and store it with the
1311 // template-deduction information.
1312 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1313 Diagnostic DiagInfo(&Diags);
1314 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1315 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1318 Diags.setLastDiagnosticIgnored(true);
1322 case DiagnosticIDs::SFINAE_AccessControl: {
1323 // Per C++ Core Issue 1170, access control is part of SFINAE.
1324 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1325 // make access control a part of SFINAE for the purposes of checking
1327 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
1330 SourceLocation Loc = Diags.getCurrentDiagLoc();
1332 // Suppress this diagnostic.
1335 // Make a copy of this suppressed diagnostic and store it with the
1336 // template-deduction information.
1337 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1338 Diagnostic DiagInfo(&Diags);
1339 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1340 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1343 Diags.setLastDiagnosticIgnored(true);
1346 // Now the diagnostic state is clear, produce a C++98 compatibility
1348 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1350 // The last diagnostic which Sema produced was ignored. Suppress any
1351 // notes attached to it.
1352 Diags.setLastDiagnosticIgnored(true);
1356 case DiagnosticIDs::SFINAE_Suppress:
1357 // Make a copy of this suppressed diagnostic and store it with the
1358 // template-deduction information;
1360 Diagnostic DiagInfo(&Diags);
1361 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1362 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1365 // Suppress this diagnostic.
1366 Diags.setLastDiagnosticIgnored(true);
1372 // Copy the diagnostic printing policy over the ASTContext printing policy.
1373 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1374 Context.setPrintingPolicy(getPrintingPolicy());
1376 // Emit the diagnostic.
1377 if (!Diags.EmitCurrentDiagnostic())
1380 // If this is not a note, and we're in a template instantiation
1381 // that is different from the last template instantiation where
1382 // we emitted an error, print a template instantiation
1384 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1385 PrintContextStack();
1388 Sema::SemaDiagnosticBuilder
1389 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1390 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1396 // Print notes showing how we can reach FD starting from an a priori
1397 // known-callable function.
1398 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1399 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1400 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1401 DiagnosticBuilder Builder(
1402 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1403 Builder << FnIt->second.FD;
1404 Builder.setForceEmit();
1406 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1410 // Emit any deferred diagnostics for FD and erase them from the map in which
1412 static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
1413 auto It = S.DeviceDeferredDiags.find(FD);
1414 if (It == S.DeviceDeferredDiags.end())
1416 bool HasWarningOrError = false;
1417 for (PartialDiagnosticAt &PDAt : It->second) {
1418 const SourceLocation &Loc = PDAt.first;
1419 const PartialDiagnostic &PD = PDAt.second;
1420 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1421 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1422 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1423 Builder.setForceEmit();
1426 S.DeviceDeferredDiags.erase(It);
1428 // FIXME: Should this be called after every warning/error emitted in the loop
1429 // above, instead of just once per function? That would be consistent with
1430 // how we handle immediate errors, but it also seems like a bit much.
1431 if (HasWarningOrError && ShowCallStack)
1432 emitCallStackNotes(S, FD);
1435 // In CUDA, there are some constructs which may appear in semantically-valid
1436 // code, but trigger errors if we ever generate code for the function in which
1437 // they appear. Essentially every construct you're not allowed to use on the
1438 // device falls into this category, because you are allowed to use these
1439 // constructs in a __host__ __device__ function, but only if that function is
1440 // never codegen'ed on the device.
1442 // To handle semantic checking for these constructs, we keep track of the set of
1443 // functions we know will be emitted, either because we could tell a priori that
1444 // they would be emitted, or because they were transitively called by a
1445 // known-emitted function.
1447 // We also keep a partial call graph of which not-known-emitted functions call
1448 // which other not-known-emitted functions.
1450 // When we see something which is illegal if the current function is emitted
1451 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1452 // CheckCUDACall), we first check if the current function is known-emitted. If
1453 // so, we immediately output the diagnostic.
1455 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1456 // until we discover that the function is known-emitted, at which point we take
1457 // it out of this map and emit the diagnostic.
1459 Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1460 unsigned DiagID, FunctionDecl *Fn,
1462 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1463 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1468 case K_ImmediateWithCallStack:
1469 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1472 assert(Fn && "Must have a function to attach the deferred diag to.");
1473 auto &Diags = S.DeviceDeferredDiags[Fn];
1474 PartialDiagId.emplace(Diags.size());
1475 Diags.emplace_back(Loc, S.PDiag(DiagID));
1480 Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1481 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1482 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1483 PartialDiagId(D.PartialDiagId) {
1484 // Clean the previous diagnostics.
1485 D.ShowCallStack = false;
1486 D.ImmediateDiag.reset();
1487 D.PartialDiagId.reset();
1490 Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1491 if (ImmediateDiag) {
1492 // Emit our diagnostic and, if it was a warning or error, output a callstack
1493 // if Fn isn't a priori known-emitted.
1494 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1495 DiagID, Loc) >= DiagnosticsEngine::Warning;
1496 ImmediateDiag.reset(); // Emit the immediate diag.
1497 if (IsWarningOrError && ShowCallStack)
1498 emitCallStackNotes(S, Fn);
1500 assert((!PartialDiagId || ShowCallStack) &&
1501 "Must always show call stack for deferred diags.");
1505 // Indicate that this function (and thus everything it transtively calls) will
1506 // be codegen'ed, and emit any deferred diagnostics on this function and its
1507 // (transitive) callees.
1508 void Sema::markKnownEmitted(
1509 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1510 SourceLocation OrigLoc,
1511 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1512 // Nothing to do if we already know that FD is emitted.
1513 if (IsKnownEmitted(S, OrigCallee)) {
1514 assert(!S.DeviceCallGraph.count(OrigCallee));
1518 // We've just discovered that OrigCallee is known-emitted. Walk our call
1519 // graph to see what else we can now discover also must be emitted.
1522 FunctionDecl *Caller;
1523 FunctionDecl *Callee;
1526 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1527 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1528 Seen.insert(OrigCallee);
1529 while (!Worklist.empty()) {
1530 CallInfo C = Worklist.pop_back_val();
1531 assert(!IsKnownEmitted(S, C.Callee) &&
1532 "Worklist should not contain known-emitted functions.");
1533 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1534 emitDeferredDiags(S, C.Callee, C.Caller);
1536 // If this is a template instantiation, explore its callgraph as well:
1537 // Non-dependent calls are part of the template's callgraph, while dependent
1538 // calls are part of to the instantiation's call graph.
1539 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1540 FunctionDecl *TemplFD = Templ->getAsFunction();
1541 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1542 Seen.insert(TemplFD);
1544 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1548 // Add all functions called by Callee to our worklist.
1549 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1550 if (CGIt == S.DeviceCallGraph.end())
1553 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1555 FunctionDecl *NewCallee = FDLoc.first;
1556 SourceLocation CallLoc = FDLoc.second;
1557 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1559 Seen.insert(NewCallee);
1561 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1564 // C.Callee is now known-emitted, so we no longer need to maintain its list
1565 // of callees in DeviceCallGraph.
1566 S.DeviceCallGraph.erase(CGIt);
1570 Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
1571 if (LangOpts.OpenMP)
1572 return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID)
1573 : diagIfOpenMPHostCode(Loc, DiagID);
1574 if (getLangOpts().CUDA)
1575 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1576 : CUDADiagIfHostCode(Loc, DiagID);
1577 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1578 getCurFunctionDecl(), *this);
1581 /// Looks through the macro-expansion chain for the given
1582 /// location, looking for a macro expansion with the given name.
1583 /// If one is found, returns true and sets the location to that
1585 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1586 SourceLocation loc = locref;
1587 if (!loc.isMacroID()) return false;
1589 // There's no good way right now to look at the intermediate
1590 // expansions, so just jump to the expansion location.
1591 loc = getSourceManager().getExpansionLoc(loc);
1593 // If that's written with the name, stop here.
1594 SmallVector<char, 16> buffer;
1595 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1602 /// Determines the active Scope associated with the given declaration
1605 /// This routine maps a declaration context to the active Scope object that
1606 /// represents that declaration context in the parser. It is typically used
1607 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1608 /// declarations) that injects a name for name-lookup purposes and, therefore,
1609 /// must update the Scope.
1611 /// \returns The scope corresponding to the given declaraion context, or NULL
1612 /// if no such scope is open.
1613 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
1618 Ctx = Ctx->getPrimaryContext();
1619 for (Scope *S = getCurScope(); S; S = S->getParent()) {
1620 // Ignore scopes that cannot have declarations. This is important for
1621 // out-of-line definitions of static class members.
1622 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1623 if (DeclContext *Entity = S->getEntity())
1624 if (Ctx == Entity->getPrimaryContext())
1631 /// Enter a new function scope
1632 void Sema::PushFunctionScope() {
1633 if (FunctionScopes.empty() && CachedFunctionScope) {
1634 // Use CachedFunctionScope to avoid allocating memory when possible.
1635 CachedFunctionScope->Clear();
1636 FunctionScopes.push_back(CachedFunctionScope.release());
1638 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1640 if (LangOpts.OpenMP)
1641 pushOpenMPFunctionRegion();
1644 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1645 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1646 BlockScope, Block));
1649 LambdaScopeInfo *Sema::PushLambdaScope() {
1650 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1651 FunctionScopes.push_back(LSI);
1655 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1656 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1657 LSI->AutoTemplateParameterDepth = Depth;
1661 "Remove assertion if intentionally called in a non-lambda context.");
1664 // Check that the type of the VarDecl has an accessible copy constructor and
1665 // resolve its destructor's exception specification.
1666 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1667 QualType T = VD->getType();
1668 EnterExpressionEvaluationContext scope(
1669 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1670 SourceLocation Loc = VD->getLocation();
1672 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1673 ExprResult Result = S.PerformMoveOrCopyInitialization(
1674 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1675 VarRef, /*AllowNRVO=*/true);
1676 if (!Result.isInvalid()) {
1677 Result = S.MaybeCreateExprWithCleanups(Result);
1678 Expr *Init = Result.getAs<Expr>();
1679 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1682 // The destructor's exception specification is needed when IRGen generates
1683 // block copy/destroy functions. Resolve it here.
1684 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1685 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1686 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1687 S.ResolveExceptionSpec(Loc, FPT);
1691 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1692 // Set the EscapingByref flag of __block variables captured by
1694 for (const BlockDecl *BD : FSI.Blocks) {
1695 for (const BlockDecl::Capture &BC : BD->captures()) {
1696 VarDecl *VD = BC.getVariable();
1697 if (VD->hasAttr<BlocksAttr>()) {
1698 // Nothing to do if this is a __block variable captured by a
1699 // non-escaping block.
1700 if (BD->doesNotEscape())
1702 VD->setEscapingByref();
1704 // Check whether the captured variable is or contains an object of
1705 // non-trivial C union type.
1706 QualType CapType = BC.getVariable()->getType();
1707 if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||
1708 CapType.hasNonTrivialToPrimitiveCopyCUnion())
1709 S.checkNonTrivialCUnion(BC.getVariable()->getType(),
1710 BD->getCaretLocation(),
1711 Sema::NTCUC_BlockCapture,
1712 Sema::NTCUK_Destruct|Sema::NTCUK_Copy);
1716 for (VarDecl *VD : FSI.ByrefBlockVars) {
1717 // __block variables might require us to capture a copy-initializer.
1718 if (!VD->isEscapingByref())
1720 // It's currently invalid to ever have a __block variable with an
1721 // array type; should we diagnose that here?
1722 // Regardless, we don't want to ignore array nesting when
1723 // constructing this copy.
1724 if (VD->getType()->isStructureOrClassType())
1725 checkEscapingByref(VD, S);
1729 /// Pop a function (or block or lambda or captured region) scope from the stack.
1731 /// \param WP The warning policy to use for CFG-based warnings, or null if such
1732 /// warnings should not be produced.
1733 /// \param D The declaration corresponding to this function scope, if producing
1734 /// CFG-based warnings.
1735 /// \param BlockType The type of the block expression, if D is a BlockDecl.
1736 Sema::PoppedFunctionScopePtr
1737 Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1738 const Decl *D, QualType BlockType) {
1739 assert(!FunctionScopes.empty() && "mismatched push/pop!");
1741 markEscapingByrefs(*FunctionScopes.back(), *this);
1743 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1744 PoppedFunctionScopeDeleter(this));
1746 if (LangOpts.OpenMP)
1747 popOpenMPFunctionRegion(Scope.get());
1749 // Issue any analysis-based warnings.
1751 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1753 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1754 Diag(PUD.Loc, PUD.PD);
1759 void Sema::PoppedFunctionScopeDeleter::
1760 operator()(sema::FunctionScopeInfo *Scope) const {
1761 // Stash the function scope for later reuse if it's for a normal function.
1762 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1763 Self->CachedFunctionScope.reset(Scope);
1768 void Sema::PushCompoundScope(bool IsStmtExpr) {
1769 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1772 void Sema::PopCompoundScope() {
1773 FunctionScopeInfo *CurFunction = getCurFunction();
1774 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1776 CurFunction->CompoundScopes.pop_back();
1779 /// Determine whether any errors occurred within this function/method/
1781 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1782 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1785 void Sema::setFunctionHasBranchIntoScope() {
1786 if (!FunctionScopes.empty())
1787 FunctionScopes.back()->setHasBranchIntoScope();
1790 void Sema::setFunctionHasBranchProtectedScope() {
1791 if (!FunctionScopes.empty())
1792 FunctionScopes.back()->setHasBranchProtectedScope();
1795 void Sema::setFunctionHasIndirectGoto() {
1796 if (!FunctionScopes.empty())
1797 FunctionScopes.back()->setHasIndirectGoto();
1800 BlockScopeInfo *Sema::getCurBlock() {
1801 if (FunctionScopes.empty())
1804 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1805 if (CurBSI && CurBSI->TheDecl &&
1806 !CurBSI->TheDecl->Encloses(CurContext)) {
1807 // We have switched contexts due to template instantiation.
1808 assert(!CodeSynthesisContexts.empty());
1815 FunctionScopeInfo *Sema::getEnclosingFunction() const {
1816 if (FunctionScopes.empty())
1819 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1820 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1822 return FunctionScopes[e];
1827 LambdaScopeInfo *Sema::getEnclosingLambda() const {
1828 for (auto *Scope : llvm::reverse(FunctionScopes)) {
1829 if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
1830 if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
1831 // We have switched contexts due to template instantiation.
1832 // FIXME: We should swap out the FunctionScopes during code synthesis
1833 // so that we don't need to check for this.
1834 assert(!CodeSynthesisContexts.empty());
1843 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1844 if (FunctionScopes.empty())
1847 auto I = FunctionScopes.rbegin();
1848 if (IgnoreNonLambdaCapturingScope) {
1849 auto E = FunctionScopes.rend();
1850 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1855 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1856 if (CurLSI && CurLSI->Lambda &&
1857 !CurLSI->Lambda->Encloses(CurContext)) {
1858 // We have switched contexts due to template instantiation.
1859 assert(!CodeSynthesisContexts.empty());
1866 // We have a generic lambda if we parsed auto parameters, or we have
1867 // an associated template parameter list.
1868 LambdaScopeInfo *Sema::getCurGenericLambda() {
1869 if (LambdaScopeInfo *LSI = getCurLambda()) {
1870 return (LSI->TemplateParams.size() ||
1871 LSI->GLTemplateParameterList) ? LSI : nullptr;
1877 void Sema::ActOnComment(SourceRange Comment) {
1878 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1879 SourceMgr.isInSystemHeader(Comment.getBegin()))
1881 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1882 if (RC.isAlmostTrailingComment()) {
1883 SourceRange MagicMarkerRange(Comment.getBegin(),
1884 Comment.getBegin().getLocWithOffset(3));
1885 StringRef MagicMarkerText;
1886 switch (RC.getKind()) {
1887 case RawComment::RCK_OrdinaryBCPL:
1888 MagicMarkerText = "///<";
1890 case RawComment::RCK_OrdinaryC:
1891 MagicMarkerText = "/**<";
1894 llvm_unreachable("if this is an almost Doxygen comment, "
1895 "it should be ordinary");
1897 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1898 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1900 Context.addComment(RC);
1903 // Pin this vtable to this file.
1904 ExternalSemaSource::~ExternalSemaSource() {}
1906 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1907 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
1909 void ExternalSemaSource::ReadKnownNamespaces(
1910 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1913 void ExternalSemaSource::ReadUndefinedButUsed(
1914 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1916 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1917 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1919 /// Figure out if an expression could be turned into a call.
1921 /// Use this when trying to recover from an error where the programmer may have
1922 /// written just the name of a function instead of actually calling it.
1924 /// \param E - The expression to examine.
1925 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1926 /// with no arguments, this parameter is set to the type returned by such a
1927 /// call; otherwise, it is set to an empty QualType.
1928 /// \param OverloadSet - If the expression is an overloaded function
1929 /// name, this parameter is populated with the decls of the various overloads.
1930 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1931 UnresolvedSetImpl &OverloadSet) {
1932 ZeroArgCallReturnTy = QualType();
1933 OverloadSet.clear();
1935 const OverloadExpr *Overloads = nullptr;
1936 bool IsMemExpr = false;
1937 if (E.getType() == Context.OverloadTy) {
1938 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1940 // Ignore overloads that are pointer-to-member constants.
1941 if (FR.HasFormOfMemberPointer)
1944 Overloads = FR.Expression;
1945 } else if (E.getType() == Context.BoundMemberTy) {
1946 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1950 bool Ambiguous = false;
1954 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1955 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1956 OverloadSet.addDecl(*it);
1958 // Check whether the function is a non-template, non-member which takes no
1962 if (const FunctionDecl *OverloadDecl
1963 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1964 if (OverloadDecl->getMinRequiredArguments() == 0) {
1965 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1966 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1967 OverloadDecl->isCPUSpecificMultiVersion()))) {
1968 ZeroArgCallReturnTy = QualType();
1971 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1972 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1973 OverloadDecl->isCPUSpecificMultiVersion();
1979 // If it's not a member, use better machinery to try to resolve the call
1981 return !ZeroArgCallReturnTy.isNull();
1984 // Attempt to call the member with no arguments - this will correctly handle
1985 // member templates with defaults/deduction of template arguments, overloads
1986 // with default arguments, etc.
1987 if (IsMemExpr && !E.isTypeDependent()) {
1988 Sema::TentativeAnalysisScope Trap(*this);
1989 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1990 None, SourceLocation());
1992 ZeroArgCallReturnTy = R.get()->getType();
1998 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1999 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
2000 if (Fun->getMinRequiredArguments() == 0)
2001 ZeroArgCallReturnTy = Fun->getReturnType();
2006 // We don't have an expression that's convenient to get a FunctionDecl from,
2007 // but we can at least check if the type is "function of 0 arguments".
2008 QualType ExprTy = E.getType();
2009 const FunctionType *FunTy = nullptr;
2010 QualType PointeeTy = ExprTy->getPointeeType();
2011 if (!PointeeTy.isNull())
2012 FunTy = PointeeTy->getAs<FunctionType>();
2014 FunTy = ExprTy->getAs<FunctionType>();
2016 if (const FunctionProtoType *FPT =
2017 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
2018 if (FPT->getNumParams() == 0)
2019 ZeroArgCallReturnTy = FunTy->getReturnType();
2025 /// Give notes for a set of overloads.
2027 /// A companion to tryExprAsCall. In cases when the name that the programmer
2028 /// wrote was an overloaded function, we may be able to make some guesses about
2029 /// plausible overloads based on their return types; such guesses can be handed
2030 /// off to this method to be emitted as notes.
2032 /// \param Overloads - The overloads to note.
2033 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
2034 /// -fshow-overloads=best, this is the location to attach to the note about too
2035 /// many candidates. Typically this will be the location of the original
2036 /// ill-formed expression.
2037 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
2038 const SourceLocation FinalNoteLoc) {
2039 int ShownOverloads = 0;
2040 int SuppressedOverloads = 0;
2041 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
2042 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2043 // FIXME: Magic number for max shown overloads stolen from
2044 // OverloadCandidateSet::NoteCandidates.
2045 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
2046 ++SuppressedOverloads;
2050 NamedDecl *Fn = (*It)->getUnderlyingDecl();
2051 // Don't print overloads for non-default multiversioned functions.
2052 if (const auto *FD = Fn->getAsFunction()) {
2053 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
2054 !FD->getAttr<TargetAttr>()->isDefaultVersion())
2057 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2061 if (SuppressedOverloads)
2062 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2063 << SuppressedOverloads;
2066 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2067 const UnresolvedSetImpl &Overloads,
2068 bool (*IsPlausibleResult)(QualType)) {
2069 if (!IsPlausibleResult)
2070 return noteOverloads(S, Overloads, Loc);
2072 UnresolvedSet<2> PlausibleOverloads;
2073 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2074 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2075 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2076 QualType OverloadResultTy = OverloadDecl->getReturnType();
2077 if (IsPlausibleResult(OverloadResultTy))
2078 PlausibleOverloads.addDecl(It.getDecl());
2080 noteOverloads(S, PlausibleOverloads, Loc);
2083 /// Determine whether the given expression can be called by just
2084 /// putting parentheses after it. Notably, expressions with unary
2085 /// operators can't be because the unary operator will start parsing
2086 /// outside the call.
2087 static bool IsCallableWithAppend(Expr *E) {
2088 E = E->IgnoreImplicit();
2089 return (!isa<CStyleCastExpr>(E) &&
2090 !isa<UnaryOperator>(E) &&
2091 !isa<BinaryOperator>(E) &&
2092 !isa<CXXOperatorCallExpr>(E));
2095 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2096 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2097 E = UO->getSubExpr();
2099 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2100 if (ULE->getNumDecls() == 0)
2103 const NamedDecl *ND = *ULE->decls_begin();
2104 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2105 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2110 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2112 bool (*IsPlausibleResult)(QualType)) {
2113 SourceLocation Loc = E.get()->getExprLoc();
2114 SourceRange Range = E.get()->getSourceRange();
2116 QualType ZeroArgCallTy;
2117 UnresolvedSet<4> Overloads;
2118 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2119 !ZeroArgCallTy.isNull() &&
2120 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2121 // At this point, we know E is potentially callable with 0
2122 // arguments and that it returns something of a reasonable type,
2123 // so we can emit a fixit and carry on pretending that E was
2124 // actually a CallExpr.
2125 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2126 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2127 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2128 << (IsCallableWithAppend(E.get())
2129 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2132 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2134 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2136 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2137 Range.getEnd().getLocWithOffset(1));
2141 if (!ForceComplain) return false;
2143 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2144 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2146 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2151 IdentifierInfo *Sema::getSuperIdentifier() const {
2153 Ident_super = &Context.Idents.get("super");
2157 IdentifierInfo *Sema::getFloat128Identifier() const {
2158 if (!Ident___float128)
2159 Ident___float128 = &Context.Idents.get("__float128");
2160 return Ident___float128;
2163 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
2164 CapturedRegionKind K,
2165 unsigned OpenMPCaptureLevel) {
2166 auto *CSI = new CapturedRegionScopeInfo(
2167 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2168 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2169 OpenMPCaptureLevel);
2170 CSI->ReturnType = Context.VoidTy;
2171 FunctionScopes.push_back(CSI);
2174 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2175 if (FunctionScopes.empty())
2178 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2181 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2182 Sema::getMismatchingDeleteExpressions() const {
2186 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2189 llvm::SmallVector<StringRef, 1> Exts;
2190 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2191 auto CanT = T.getCanonicalType().getTypePtr();
2192 for (auto &I : Exts)
2193 OpenCLTypeExtMap[CanT].insert(I.str());
2196 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2197 llvm::SmallVector<StringRef, 1> Exts;
2198 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2201 for (auto &I : Exts)
2202 OpenCLDeclExtMap[FD].insert(I.str());
2205 void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2206 if (CurrOpenCLExtension.empty())
2208 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2211 void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2212 if (CurrOpenCLExtension.empty())
2214 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2217 std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2218 if (!OpenCLDeclExtMap.empty())
2219 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2224 std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2225 if (!OpenCLTypeExtMap.empty())
2226 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2231 template <typename T, typename MapT>
2232 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2233 std::string ExtensionNames = "";
2234 auto Loc = Map.find(FDT);
2236 for (auto const& I : Loc->second) {
2237 ExtensionNames += I;
2238 ExtensionNames += " ";
2240 ExtensionNames.pop_back();
2242 return ExtensionNames;
2245 bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2246 auto Loc = OpenCLDeclExtMap.find(FD);
2247 if (Loc == OpenCLDeclExtMap.end())
2249 for (auto &I : Loc->second) {
2250 if (!getOpenCLOptions().isEnabled(I))
2256 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2257 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2258 DiagInfoT DiagInfo, MapT &Map,
2260 SourceRange SrcRange) {
2261 auto Loc = Map.find(D);
2262 if (Loc == Map.end())
2264 bool Disabled = false;
2265 for (auto &I : Loc->second) {
2266 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2267 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2275 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2276 // Check extensions for declared types.
2277 Decl *Decl = nullptr;
2278 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2279 Decl = TypedefT->getDecl();
2280 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2281 Decl = TagT->getDecl();
2282 auto Loc = DS.getTypeSpecTypeLoc();
2284 // Check extensions for vector types.
2285 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2286 if (QT->isExtVectorType()) {
2287 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2288 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2291 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2294 // Check extensions for builtin types.
2295 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2296 QT, OpenCLTypeExtMap);
2299 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2300 IdentifierInfo *FnName = D.getIdentifier();
2301 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2302 OpenCLDeclExtMap, 1, D.getSourceRange());