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/TargetInfo.h"
26 #include "clang/Lex/HeaderSearch.h"
27 #include "clang/Lex/Preprocessor.h"
28 #include "clang/Sema/CXXFieldCollector.h"
29 #include "clang/Sema/DelayedDiagnostic.h"
30 #include "clang/Sema/ExternalSemaSource.h"
31 #include "clang/Sema/Initialization.h"
32 #include "clang/Sema/MultiplexExternalSemaSource.h"
33 #include "clang/Sema/ObjCMethodList.h"
34 #include "clang/Sema/Scope.h"
35 #include "clang/Sema/ScopeInfo.h"
36 #include "clang/Sema/SemaConsumer.h"
37 #include "clang/Sema/SemaInternal.h"
38 #include "clang/Sema/TemplateDeduction.h"
39 #include "clang/Sema/TemplateInstCallback.h"
40 #include "llvm/ADT/DenseMap.h"
41 #include "llvm/ADT/SmallSet.h"
42 #include "llvm/Support/TimeProfiler.h"
44 using namespace clang;
47 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
48 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
51 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
53 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
54 const Preprocessor &PP) {
55 PrintingPolicy Policy = Context.getPrintingPolicy();
56 // In diagnostics, we print _Bool as bool if the latter is defined as the
58 Policy.Bool = Context.getLangOpts().Bool;
60 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
61 Policy.Bool = BoolMacro->isObjectLike() &&
62 BoolMacro->getNumTokens() == 1 &&
63 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
70 void Sema::ActOnTranslationUnitScope(Scope *S) {
72 PushDeclContext(S, Context.getTranslationUnitDecl());
78 class SemaPPCallbacks : public PPCallbacks {
80 llvm::SmallVector<SourceLocation, 8> IncludeStack;
83 void set(Sema &S) { this->S = &S; }
85 void reset() { S = nullptr; }
87 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
88 SrcMgr::CharacteristicKind FileType,
89 FileID PrevFID) override {
94 SourceManager &SM = S->getSourceManager();
95 SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
96 if (IncludeLoc.isValid()) {
97 if (llvm::timeTraceProfilerEnabled()) {
98 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
99 llvm::timeTraceProfilerBegin(
100 "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
103 IncludeStack.push_back(IncludeLoc);
104 S->DiagnoseNonDefaultPragmaPack(
105 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
110 if (!IncludeStack.empty()) {
111 if (llvm::timeTraceProfilerEnabled())
112 llvm::timeTraceProfilerEnd();
114 S->DiagnoseNonDefaultPragmaPack(
115 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
116 IncludeStack.pop_back_val());
125 } // end namespace sema
126 } // end namespace clang
128 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
129 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
130 : ExternalSource(nullptr), isMultiplexExternalSource(false),
131 FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
132 Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
133 SourceMgr(PP.getSourceManager()), CollectStats(false),
134 CodeCompleter(CodeCompleter), CurContext(nullptr),
135 OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
136 MSPointerToMemberRepresentationMethod(
137 LangOpts.getMSPointerToMemberRepresentationMethod()),
138 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
139 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
140 CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
141 PragmaAttributeCurrentTargetDecl(nullptr),
142 IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
143 LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
144 StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
145 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
146 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
147 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
148 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
149 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
150 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
151 TUKind(TUKind), NumSFINAEErrors(0),
152 FullyCheckedComparisonCategories(
153 static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
154 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
155 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
156 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
157 TyposCorrected(0), AnalysisWarnings(*this),
158 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
159 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
161 isConstantEvaluatedOverride = false;
163 LoadedExternalKnownNamespaces = false;
164 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
165 NSNumberLiteralMethods[I] = nullptr;
167 if (getLangOpts().ObjC)
168 NSAPIObj.reset(new NSAPI(Context));
170 if (getLangOpts().CPlusPlus)
171 FieldCollector.reset(new CXXFieldCollector());
173 // Tell diagnostics how to render things from the AST library.
174 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
176 ExprEvalContexts.emplace_back(
177 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
178 nullptr, ExpressionEvaluationContextRecord::EK_Other);
180 // Initialization of data sharing attributes stack for OpenMP
181 InitDataSharingAttributesStack();
183 std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
184 llvm::make_unique<sema::SemaPPCallbacks>();
185 SemaPPCallbackHandler = Callbacks.get();
186 PP.addPPCallbacks(std::move(Callbacks));
187 SemaPPCallbackHandler->set(*this);
190 void Sema::addImplicitTypedef(StringRef Name, QualType T) {
191 DeclarationName DN = &Context.Idents.get(Name);
192 if (IdResolver.begin(DN) == IdResolver.end())
193 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
196 void Sema::Initialize() {
197 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
198 SC->InitializeSema(*this);
200 // Tell the external Sema source about this Sema object.
201 if (ExternalSemaSource *ExternalSema
202 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
203 ExternalSema->InitializeSema(*this);
205 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
206 // will not be able to merge any duplicate __va_list_tag decls correctly.
207 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
212 // Initialize predefined 128-bit integer types, if needed.
213 if (Context.getTargetInfo().hasInt128Type()) {
214 // If either of the 128-bit integer types are unavailable to name lookup,
216 DeclarationName Int128 = &Context.Idents.get("__int128_t");
217 if (IdResolver.begin(Int128) == IdResolver.end())
218 PushOnScopeChains(Context.getInt128Decl(), TUScope);
220 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
221 if (IdResolver.begin(UInt128) == IdResolver.end())
222 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
226 // Initialize predefined Objective-C types:
227 if (getLangOpts().ObjC) {
228 // If 'SEL' does not yet refer to any declarations, make it refer to the
230 DeclarationName SEL = &Context.Idents.get("SEL");
231 if (IdResolver.begin(SEL) == IdResolver.end())
232 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
234 // If 'id' does not yet refer to any declarations, make it refer to the
236 DeclarationName Id = &Context.Idents.get("id");
237 if (IdResolver.begin(Id) == IdResolver.end())
238 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
240 // Create the built-in typedef for 'Class'.
241 DeclarationName Class = &Context.Idents.get("Class");
242 if (IdResolver.begin(Class) == IdResolver.end())
243 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
245 // Create the built-in forward declaratino for 'Protocol'.
246 DeclarationName Protocol = &Context.Idents.get("Protocol");
247 if (IdResolver.begin(Protocol) == IdResolver.end())
248 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
251 // Create the internal type for the *StringMakeConstantString builtins.
252 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
253 if (IdResolver.begin(ConstantString) == IdResolver.end())
254 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
256 // Initialize Microsoft "predefined C++ types".
257 if (getLangOpts().MSVCCompat) {
258 if (getLangOpts().CPlusPlus &&
259 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
260 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
263 addImplicitTypedef("size_t", Context.getSizeType());
266 // Initialize predefined OpenCL types and supported extensions and (optional)
268 if (getLangOpts().OpenCL) {
269 getOpenCLOptions().addSupport(
270 Context.getTargetInfo().getSupportedOpenCLOpts());
271 getOpenCLOptions().enableSupportedCore(getLangOpts());
272 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
273 addImplicitTypedef("event_t", Context.OCLEventTy);
274 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
275 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
276 addImplicitTypedef("queue_t", Context.OCLQueueTy);
277 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
278 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
279 addImplicitTypedef("atomic_uint",
280 Context.getAtomicType(Context.UnsignedIntTy));
281 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
282 addImplicitTypedef("atomic_long", AtomicLongT);
283 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
284 addImplicitTypedef("atomic_ulong", AtomicULongT);
285 addImplicitTypedef("atomic_float",
286 Context.getAtomicType(Context.FloatTy));
287 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
288 addImplicitTypedef("atomic_double", AtomicDoubleT);
289 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
290 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
291 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
292 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
293 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
294 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
295 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
296 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
297 addImplicitTypedef("atomic_size_t", AtomicSizeT);
298 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
299 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
301 // OpenCL v2.0 s6.13.11.6:
302 // - The atomic_long and atomic_ulong types are supported if the
303 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
304 // extensions are supported.
305 // - The atomic_double type is only supported if double precision
306 // is supported and the cl_khr_int64_base_atomics and
307 // cl_khr_int64_extended_atomics extensions are supported.
308 // - If the device address space is 64-bits, the data types
309 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
310 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
311 // cl_khr_int64_extended_atomics extensions are supported.
312 std::vector<QualType> Atomic64BitTypes;
313 Atomic64BitTypes.push_back(AtomicLongT);
314 Atomic64BitTypes.push_back(AtomicULongT);
315 Atomic64BitTypes.push_back(AtomicDoubleT);
316 if (Context.getTypeSize(AtomicSizeT) == 64) {
317 Atomic64BitTypes.push_back(AtomicSizeT);
318 Atomic64BitTypes.push_back(AtomicIntPtrT);
319 Atomic64BitTypes.push_back(AtomicUIntPtrT);
320 Atomic64BitTypes.push_back(AtomicPtrDiffT);
322 for (auto &I : Atomic64BitTypes)
323 setOpenCLExtensionForType(I,
324 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
326 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
329 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
331 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
332 setOpenCLExtensionForType(Context.Id, Ext);
333 #include "clang/Basic/OpenCLImageTypes.def"
334 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
335 addImplicitTypedef(#ExtType, Context.Id##Ty); \
336 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
337 #include "clang/Basic/OpenCLExtensionTypes.def"
340 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
341 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
342 if (IdResolver.begin(MSVaList) == IdResolver.end())
343 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
346 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
347 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
348 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
352 if (VisContext) FreeVisContext();
354 // Kill all the active scopes.
355 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
358 // Tell the SemaConsumer to forget about us; we're going out of scope.
359 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
362 // Detach from the external Sema source.
363 if (ExternalSemaSource *ExternalSema
364 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
365 ExternalSema->ForgetSema();
367 // If Sema's ExternalSource is the multiplexer - we own it.
368 if (isMultiplexExternalSource)
369 delete ExternalSource;
371 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
373 // Destroys data sharing attributes stack for OpenMP
374 DestroyDataSharingAttributesStack();
376 // Detach from the PP callback handler which outlives Sema since it's owned
377 // by the preprocessor.
378 SemaPPCallbackHandler->reset();
380 assert(DelayedTypos.empty() && "Uncorrected typos!");
383 /// makeUnavailableInSystemHeader - There is an error in the current
384 /// context. If we're still in a system header, and we can plausibly
385 /// make the relevant declaration unavailable instead of erroring, do
386 /// so and return true.
387 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
388 UnavailableAttr::ImplicitReason reason) {
389 // If we're not in a function, it's an error.
390 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
391 if (!fn) return false;
393 // If we're in template instantiation, it's an error.
394 if (inTemplateInstantiation())
397 // If that function's not in a system header, it's an error.
398 if (!Context.getSourceManager().isInSystemHeader(loc))
401 // If the function is already unavailable, it's not an error.
402 if (fn->hasAttr<UnavailableAttr>()) return true;
404 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
408 ASTMutationListener *Sema::getASTMutationListener() const {
409 return getASTConsumer().GetASTMutationListener();
412 ///Registers an external source. If an external source already exists,
413 /// creates a multiplex external source and appends to it.
415 ///\param[in] E - A non-null external sema source.
417 void Sema::addExternalSource(ExternalSemaSource *E) {
418 assert(E && "Cannot use with NULL ptr");
420 if (!ExternalSource) {
425 if (isMultiplexExternalSource)
426 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
428 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
429 isMultiplexExternalSource = true;
433 /// Print out statistics about the semantic analysis.
434 void Sema::PrintStats() const {
435 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
436 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
438 BumpAlloc.PrintStats();
439 AnalysisWarnings.PrintStats();
442 void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
444 SourceLocation Loc) {
445 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
446 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
449 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
450 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
453 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
456 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
457 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
460 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
461 if (!getLangOpts().CPlusPlus11)
464 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
466 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
469 // If it is a macro from system header, and if the macro name is not "NULL",
471 SourceLocation MaybeMacroLoc = E->getBeginLoc();
472 if (Diags.getSuppressSystemWarnings() &&
473 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
474 !findMacroSpelling(MaybeMacroLoc, "NULL"))
477 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
478 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
481 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
482 /// If there is already an implicit cast, merge into the existing one.
483 /// The result is of the given category.
484 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
485 CastKind Kind, ExprValueKind VK,
486 const CXXCastPath *BasePath,
487 CheckedConversionKind CCK) {
489 if (VK == VK_RValue && !E->isRValue()) {
492 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
495 case CK_LValueToRValue:
496 case CK_ArrayToPointerDecay:
497 case CK_FunctionToPointerDecay:
499 case CK_NonAtomicToAtomic:
503 assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
504 "can't cast rvalue to lvalue");
507 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
508 diagnoseZeroToNullptrConversion(Kind, E);
510 QualType ExprTy = Context.getCanonicalType(E->getType());
511 QualType TypeTy = Context.getCanonicalType(Ty);
513 if (ExprTy == TypeTy)
516 // C++1z [conv.array]: The temporary materialization conversion is applied.
517 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
518 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
519 E->getValueKind() == VK_RValue) {
520 // The temporary is an lvalue in C++98 and an xvalue otherwise.
521 ExprResult Materialized = CreateMaterializeTemporaryExpr(
522 E->getType(), E, !getLangOpts().CPlusPlus11);
523 if (Materialized.isInvalid())
525 E = Materialized.get();
528 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
529 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
530 ImpCast->setType(Ty);
531 ImpCast->setValueKind(VK);
536 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
539 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
540 /// to the conversion from scalar type ScalarTy to the Boolean type.
541 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
542 switch (ScalarTy->getScalarTypeKind()) {
543 case Type::STK_Bool: return CK_NoOp;
544 case Type::STK_CPointer: return CK_PointerToBoolean;
545 case Type::STK_BlockPointer: return CK_PointerToBoolean;
546 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
547 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
548 case Type::STK_Integral: return CK_IntegralToBoolean;
549 case Type::STK_Floating: return CK_FloatingToBoolean;
550 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
551 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
552 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
554 llvm_unreachable("unknown scalar type kind");
557 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
558 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
559 if (D->getMostRecentDecl()->isUsed())
562 if (D->isExternallyVisible())
565 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
566 // If this is a function template and none of its specializations is used,
568 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
569 for (const auto *Spec : Template->specializations())
570 if (ShouldRemoveFromUnused(SemaRef, Spec))
573 // UnusedFileScopedDecls stores the first declaration.
574 // The declaration may have become definition so check again.
575 const FunctionDecl *DeclToCheck;
576 if (FD->hasBody(DeclToCheck))
577 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
579 // Later redecls may add new information resulting in not having to warn,
581 DeclToCheck = FD->getMostRecentDecl();
582 if (DeclToCheck != FD)
583 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
586 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
587 // If a variable usable in constant expressions is referenced,
588 // don't warn if it isn't used: if the value of a variable is required
589 // for the computation of a constant expression, it doesn't make sense to
590 // warn even if the variable isn't odr-used. (isReferenced doesn't
591 // precisely reflect that, but it's a decent approximation.)
592 if (VD->isReferenced() &&
593 VD->mightBeUsableInConstantExpressions(SemaRef->Context))
596 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
597 // If this is a variable template and none of its specializations is used,
599 for (const auto *Spec : Template->specializations())
600 if (ShouldRemoveFromUnused(SemaRef, Spec))
603 // UnusedFileScopedDecls stores the first declaration.
604 // The declaration may have become definition so check again.
605 const VarDecl *DeclToCheck = VD->getDefinition();
607 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
609 // Later redecls may add new information resulting in not having to warn,
611 DeclToCheck = VD->getMostRecentDecl();
612 if (DeclToCheck != VD)
613 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
619 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
620 if (auto *FD = dyn_cast<FunctionDecl>(ND))
621 return FD->isExternC();
622 return cast<VarDecl>(ND)->isExternC();
625 /// Determine whether ND is an external-linkage function or variable whose
626 /// type has no linkage.
627 bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
628 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
629 // because we also want to catch the case where its type has VisibleNoLinkage,
630 // which does not affect the linkage of VD.
631 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
632 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
633 !isFunctionOrVarDeclExternC(VD);
636 /// Obtains a sorted list of functions and variables that are undefined but
638 void Sema::getUndefinedButUsed(
639 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
640 for (const auto &UndefinedUse : UndefinedButUsed) {
641 NamedDecl *ND = UndefinedUse.first;
643 // Ignore attributes that have become invalid.
644 if (ND->isInvalidDecl()) continue;
646 // __attribute__((weakref)) is basically a definition.
647 if (ND->hasAttr<WeakRefAttr>()) continue;
649 if (isa<CXXDeductionGuideDecl>(ND))
652 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
653 // An exported function will always be emitted when defined, so even if
654 // the function is inline, it doesn't have to be emitted in this TU. An
655 // imported function implies that it has been exported somewhere else.
659 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
662 if (FD->isExternallyVisible() &&
663 !isExternalWithNoLinkageType(FD) &&
664 !FD->getMostRecentDecl()->isInlined() &&
665 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
667 if (FD->getBuiltinID())
670 auto *VD = cast<VarDecl>(ND);
671 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
673 if (VD->isExternallyVisible() &&
674 !isExternalWithNoLinkageType(VD) &&
675 !VD->getMostRecentDecl()->isInline() &&
676 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
679 // Skip VarDecls that lack formal definitions but which we know are in
680 // fact defined somewhere.
681 if (VD->isKnownToBeDefined())
685 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
689 /// checkUndefinedButUsed - Check for undefined objects with internal linkage
690 /// or that are inline.
691 static void checkUndefinedButUsed(Sema &S) {
692 if (S.UndefinedButUsed.empty()) return;
694 // Collect all the still-undefined entities with internal linkage.
695 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
696 S.getUndefinedButUsed(Undefined);
697 if (Undefined.empty()) return;
699 for (auto Undef : Undefined) {
700 ValueDecl *VD = cast<ValueDecl>(Undef.first);
701 SourceLocation UseLoc = Undef.second;
703 if (S.isExternalWithNoLinkageType(VD)) {
704 // C++ [basic.link]p8:
705 // A type without linkage shall not be used as the type of a variable
706 // or function with external linkage unless
707 // -- the entity has C language linkage
708 // -- the entity is not odr-used or is defined in the same TU
710 // As an extension, accept this in cases where the type is externally
711 // visible, since the function or variable actually can be defined in
712 // another translation unit in that case.
713 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
714 ? diag::ext_undefined_internal_type
715 : diag::err_undefined_internal_type)
716 << isa<VarDecl>(VD) << VD;
717 } else if (!VD->isExternallyVisible()) {
718 // FIXME: We can promote this to an error. The function or variable can't
719 // be defined anywhere else, so the program must necessarily violate the
720 // one definition rule.
721 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
722 << isa<VarDecl>(VD) << VD;
723 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
725 assert(FD->getMostRecentDecl()->isInlined() &&
726 "used object requires definition but isn't inline or internal?");
727 // FIXME: This is ill-formed; we should reject.
728 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
730 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
731 "used var requires definition but isn't inline or internal?");
732 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
734 if (UseLoc.isValid())
735 S.Diag(UseLoc, diag::note_used_here);
738 S.UndefinedButUsed.clear();
741 void Sema::LoadExternalWeakUndeclaredIdentifiers() {
745 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
746 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
747 for (auto &WeakID : WeakIDs)
748 WeakUndeclaredIdentifiers.insert(WeakID);
752 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
754 /// Returns true, if all methods and nested classes of the given
755 /// CXXRecordDecl are defined in this translation unit.
757 /// Should only be called from ActOnEndOfTranslationUnit so that all
758 /// definitions are actually read.
759 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
760 RecordCompleteMap &MNCComplete) {
761 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
762 if (Cache != MNCComplete.end())
763 return Cache->second;
764 if (!RD->isCompleteDefinition())
766 bool Complete = true;
767 for (DeclContext::decl_iterator I = RD->decls_begin(),
769 I != E && Complete; ++I) {
770 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
771 Complete = M->isDefined() || M->isDefaulted() ||
772 (M->isPure() && !isa<CXXDestructorDecl>(M));
773 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
774 // If the template function is marked as late template parsed at this
775 // point, it has not been instantiated and therefore we have not
776 // performed semantic analysis on it yet, so we cannot know if the type
777 // can be considered complete.
778 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
779 F->getTemplatedDecl()->isDefined();
780 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
781 if (R->isInjectedClassName())
783 if (R->hasDefinition())
784 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
790 MNCComplete[RD] = Complete;
794 /// Returns true, if the given CXXRecordDecl is fully defined in this
795 /// translation unit, i.e. all methods are defined or pure virtual and all
796 /// friends, friend functions and nested classes are fully defined in this
797 /// translation unit.
799 /// Should only be called from ActOnEndOfTranslationUnit so that all
800 /// definitions are actually read.
801 static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
802 RecordCompleteMap &RecordsComplete,
803 RecordCompleteMap &MNCComplete) {
804 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
805 if (Cache != RecordsComplete.end())
806 return Cache->second;
807 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
808 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
809 E = RD->friend_end();
810 I != E && Complete; ++I) {
811 // Check if friend classes and methods are complete.
812 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
813 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
814 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
815 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
819 // Friend functions are available through the NamedDecl of FriendDecl.
820 if (const FunctionDecl *FD =
821 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
822 Complete = FD->isDefined();
824 // This is a template friend, give up.
828 RecordsComplete[RD] = Complete;
832 void Sema::emitAndClearUnusedLocalTypedefWarnings() {
834 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
835 UnusedLocalTypedefNameCandidates);
836 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
837 if (TD->isReferenced())
839 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
840 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
842 UnusedLocalTypedefNameCandidates.clear();
845 /// This is called before the very first declaration in the translation unit
846 /// is parsed. Note that the ASTContext may have already injected some
848 void Sema::ActOnStartOfTranslationUnit() {
849 if (getLangOpts().ModulesTS &&
850 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
851 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
852 // We start in an implied global module fragment.
853 SourceLocation StartOfTU =
854 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
855 ActOnGlobalModuleFragmentDecl(StartOfTU);
856 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
860 void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
861 // No explicit actions are required at the end of the global module fragment.
862 if (Kind == TUFragmentKind::Global)
865 // Transfer late parsed template instantiations over to the pending template
866 // instantiation list. During normal compilation, the late template parser
867 // will be installed and instantiating these templates will succeed.
869 // If we are building a TU prefix for serialization, it is also safe to
870 // transfer these over, even though they are not parsed. The end of the TU
871 // should be outside of any eager template instantiation scope, so when this
872 // AST is deserialized, these templates will not be parsed until the end of
874 PendingInstantiations.insert(PendingInstantiations.end(),
875 LateParsedInstantiations.begin(),
876 LateParsedInstantiations.end());
877 LateParsedInstantiations.clear();
879 // If DefinedUsedVTables ends up marking any virtual member functions it
880 // might lead to more pending template instantiations, which we then need
884 // C++: Perform implicit template instantiations.
886 // FIXME: When we perform these implicit instantiations, we do not
887 // carefully keep track of the point of instantiation (C++ [temp.point]).
888 // This means that name lookup that occurs within the template
889 // instantiation will always happen at the end of the translation unit,
890 // so it will find some names that are not required to be found. This is
891 // valid, but we could do better by diagnosing if an instantiation uses a
892 // name that was not visible at its first point of instantiation.
893 if (ExternalSource) {
894 // Load pending instantiations from the external source.
895 SmallVector<PendingImplicitInstantiation, 4> Pending;
896 ExternalSource->ReadPendingInstantiations(Pending);
897 for (auto PII : Pending)
898 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
899 Func->setInstantiationIsPending(true);
900 PendingInstantiations.insert(PendingInstantiations.begin(),
901 Pending.begin(), Pending.end());
905 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
907 PerformPendingInstantiations();
910 assert(LateParsedInstantiations.empty() &&
911 "end of TU template instantiation should not create more "
912 "late-parsed templates");
915 /// ActOnEndOfTranslationUnit - This is called at the very end of the
916 /// translation unit when EOF is reached and all but the top-level scope is
918 void Sema::ActOnEndOfTranslationUnit() {
919 assert(DelayedDiagnostics.getCurrentPool() == nullptr
920 && "reached end of translation unit with a pool attached?");
922 // If code completion is enabled, don't perform any end-of-translation-unit
924 if (PP.isCodeCompletionEnabled())
927 // Complete translation units and modules define vtables and perform implicit
928 // instantiations. PCH files do not.
929 if (TUKind != TU_Prefix) {
930 DiagnoseUseOfUnimplementedSelectors();
932 ActOnEndOfTranslationUnitFragment(
933 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
934 Module::PrivateModuleFragment
935 ? TUFragmentKind::Private
936 : TUFragmentKind::Normal);
938 if (LateTemplateParserCleanup)
939 LateTemplateParserCleanup(OpaqueParser);
941 CheckDelayedMemberExceptionSpecs();
943 // If we are building a TU prefix for serialization, it is safe to transfer
944 // these over, even though they are not parsed. The end of the TU should be
945 // outside of any eager template instantiation scope, so when this AST is
946 // deserialized, these templates will not be parsed until the end of the
948 PendingInstantiations.insert(PendingInstantiations.end(),
949 LateParsedInstantiations.begin(),
950 LateParsedInstantiations.end());
951 LateParsedInstantiations.clear();
954 DiagnoseUnterminatedPragmaPack();
955 DiagnoseUnterminatedPragmaAttribute();
957 // All delayed member exception specs should be checked or we end up accepting
958 // incompatible declarations.
959 assert(DelayedOverridingExceptionSpecChecks.empty());
960 assert(DelayedEquivalentExceptionSpecChecks.empty());
962 // All dllexport classes should have been processed already.
963 assert(DelayedDllExportClasses.empty());
964 assert(DelayedDllExportMemberFunctions.empty());
966 // Remove file scoped decls that turned out to be used.
967 UnusedFileScopedDecls.erase(
968 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
969 UnusedFileScopedDecls.end(),
970 [this](const DeclaratorDecl *DD) {
971 return ShouldRemoveFromUnused(this, DD);
973 UnusedFileScopedDecls.end());
975 if (TUKind == TU_Prefix) {
976 // Translation unit prefixes don't need any of the checking below.
977 if (!PP.isIncrementalProcessingEnabled())
982 // Check for #pragma weak identifiers that were never declared
983 LoadExternalWeakUndeclaredIdentifiers();
984 for (auto WeakID : WeakUndeclaredIdentifiers) {
985 if (WeakID.second.getUsed())
988 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
990 if (PrevDecl != nullptr &&
991 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
992 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
993 << "'weak'" << ExpectedVariableOrFunction;
995 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
999 if (LangOpts.CPlusPlus11 &&
1000 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
1001 CheckDelegatingCtorCycles();
1003 if (!Diags.hasErrorOccurred()) {
1005 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1006 checkUndefinedButUsed(*this);
1009 // A global-module-fragment is only permitted within a module unit.
1010 bool DiagnosedMissingModuleDeclaration = false;
1011 if (!ModuleScopes.empty() &&
1012 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1013 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1014 Diag(ModuleScopes.back().BeginLoc,
1015 diag::err_module_declaration_missing_after_global_module_introducer);
1016 DiagnosedMissingModuleDeclaration = true;
1019 if (TUKind == TU_Module) {
1020 // If we are building a module interface unit, we need to have seen the
1021 // module declaration by now.
1022 if (getLangOpts().getCompilingModule() ==
1023 LangOptions::CMK_ModuleInterface &&
1024 (ModuleScopes.empty() ||
1025 !ModuleScopes.back().Module->isModulePurview()) &&
1026 !DiagnosedMissingModuleDeclaration) {
1027 // FIXME: Make a better guess as to where to put the module declaration.
1028 Diag(getSourceManager().getLocForStartOfFile(
1029 getSourceManager().getMainFileID()),
1030 diag::err_module_declaration_missing);
1033 // If we are building a module, resolve all of the exported declarations
1035 if (Module *CurrentModule = PP.getCurrentModule()) {
1036 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
1038 SmallVector<Module *, 2> Stack;
1039 Stack.push_back(CurrentModule);
1040 while (!Stack.empty()) {
1041 Module *Mod = Stack.pop_back_val();
1043 // Resolve the exported declarations and conflicts.
1044 // FIXME: Actually complain, once we figure out how to teach the
1045 // diagnostic client to deal with complaints in the module map at this
1047 ModMap.resolveExports(Mod, /*Complain=*/false);
1048 ModMap.resolveUses(Mod, /*Complain=*/false);
1049 ModMap.resolveConflicts(Mod, /*Complain=*/false);
1051 // Queue the submodules, so their exports will also be resolved.
1052 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
1056 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1057 // modules when they are built, not every time they are used.
1058 emitAndClearUnusedLocalTypedefWarnings();
1062 // A declaration of an identifier for an object that has file
1063 // scope without an initializer, and without a storage-class
1064 // specifier or with the storage-class specifier static,
1065 // constitutes a tentative definition. If a translation unit
1066 // contains one or more tentative definitions for an identifier,
1067 // and the translation unit contains no external definition for
1068 // that identifier, then the behavior is exactly as if the
1069 // translation unit contains a file scope declaration of that
1070 // identifier, with the composite type as of the end of the
1071 // translation unit, with an initializer equal to 0.
1072 llvm::SmallSet<VarDecl *, 32> Seen;
1073 for (TentativeDefinitionsType::iterator
1074 T = TentativeDefinitions.begin(ExternalSource),
1075 TEnd = TentativeDefinitions.end();
1077 VarDecl *VD = (*T)->getActingDefinition();
1079 // If the tentative definition was completed, getActingDefinition() returns
1080 // null. If we've already seen this variable before, insert()'s second
1081 // return value is false.
1082 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
1085 if (const IncompleteArrayType *ArrayT
1086 = Context.getAsIncompleteArrayType(VD->getType())) {
1087 // Set the length of the array to 1 (C99 6.9.2p5).
1088 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1089 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
1090 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1091 One, ArrayType::Normal, 0);
1093 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
1094 diag::err_tentative_def_incomplete_type))
1095 VD->setInvalidDecl();
1097 // No initialization is performed for a tentative definition.
1098 CheckCompleteVariableDeclaration(VD);
1100 // Notify the consumer that we've completed a tentative definition.
1101 if (!VD->isInvalidDecl())
1102 Consumer.CompleteTentativeDefinition(VD);
1105 // If there were errors, disable 'unused' warnings since they will mostly be
1106 // noise. Don't warn for a use from a module: either we should warn on all
1107 // file-scope declarations in modules or not at all, but whether the
1108 // declaration is used is immaterial.
1109 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
1110 // Output warning for unused file scoped decls.
1111 for (UnusedFileScopedDeclsType::iterator
1112 I = UnusedFileScopedDecls.begin(ExternalSource),
1113 E = UnusedFileScopedDecls.end(); I != E; ++I) {
1114 if (ShouldRemoveFromUnused(this, *I))
1117 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1118 const FunctionDecl *DiagD;
1119 if (!FD->hasBody(DiagD))
1121 if (DiagD->isDeleted())
1122 continue; // Deleted functions are supposed to be unused.
1123 if (DiagD->isReferenced()) {
1124 if (isa<CXXMethodDecl>(DiagD))
1125 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1126 << DiagD->getDeclName();
1128 if (FD->getStorageClass() == SC_Static &&
1129 !FD->isInlineSpecified() &&
1130 !SourceMgr.isInMainFile(
1131 SourceMgr.getExpansionLoc(FD->getLocation())))
1132 Diag(DiagD->getLocation(),
1133 diag::warn_unneeded_static_internal_decl)
1134 << DiagD->getDeclName();
1136 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1137 << /*function*/0 << DiagD->getDeclName();
1140 if (FD->getDescribedFunctionTemplate())
1141 Diag(DiagD->getLocation(), diag::warn_unused_template)
1142 << /*function*/0 << DiagD->getDeclName();
1144 Diag(DiagD->getLocation(),
1145 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1146 : diag::warn_unused_function)
1147 << DiagD->getDeclName();
1150 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1152 DiagD = cast<VarDecl>(*I);
1153 if (DiagD->isReferenced()) {
1154 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1155 << /*variable*/1 << DiagD->getDeclName();
1156 } else if (DiagD->getType().isConstQualified()) {
1157 const SourceManager &SM = SourceMgr;
1158 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1159 !PP.getLangOpts().IsHeaderFile)
1160 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1161 << DiagD->getDeclName();
1163 if (DiagD->getDescribedVarTemplate())
1164 Diag(DiagD->getLocation(), diag::warn_unused_template)
1165 << /*variable*/1 << DiagD->getDeclName();
1167 Diag(DiagD->getLocation(), diag::warn_unused_variable)
1168 << DiagD->getDeclName();
1173 emitAndClearUnusedLocalTypedefWarnings();
1176 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
1177 // FIXME: Load additional unused private field candidates from the external
1179 RecordCompleteMap RecordsComplete;
1180 RecordCompleteMap MNCComplete;
1181 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1182 E = UnusedPrivateFields.end(); I != E; ++I) {
1183 const NamedDecl *D = *I;
1184 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1185 if (RD && !RD->isUnion() &&
1186 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1187 Diag(D->getLocation(), diag::warn_unused_private_field)
1188 << D->getDeclName();
1193 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1195 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1196 for (const auto &DeletedFieldInfo : DeleteExprs) {
1197 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1198 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1199 DeleteExprLoc.second);
1204 // Check we've noticed that we're no longer parsing the initializer for every
1205 // variable. If we miss cases, then at best we have a performance issue and
1206 // at worst a rejects-valid bug.
1207 assert(ParsingInitForAutoVars.empty() &&
1208 "Didn't unmark var as having its initializer parsed");
1210 if (!PP.isIncrementalProcessingEnabled())
1215 //===----------------------------------------------------------------------===//
1216 // Helper functions.
1217 //===----------------------------------------------------------------------===//
1219 DeclContext *Sema::getFunctionLevelDeclContext() {
1220 DeclContext *DC = CurContext;
1223 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
1224 DC = DC->getParent();
1225 } else if (isa<CXXMethodDecl>(DC) &&
1226 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
1227 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1228 DC = DC->getParent()->getParent();
1236 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
1237 /// to the function decl for the function being parsed. If we're currently
1238 /// in a 'block', this returns the containing context.
1239 FunctionDecl *Sema::getCurFunctionDecl() {
1240 DeclContext *DC = getFunctionLevelDeclContext();
1241 return dyn_cast<FunctionDecl>(DC);
1244 ObjCMethodDecl *Sema::getCurMethodDecl() {
1245 DeclContext *DC = getFunctionLevelDeclContext();
1246 while (isa<RecordDecl>(DC))
1247 DC = DC->getParent();
1248 return dyn_cast<ObjCMethodDecl>(DC);
1251 NamedDecl *Sema::getCurFunctionOrMethodDecl() {
1252 DeclContext *DC = getFunctionLevelDeclContext();
1253 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
1254 return cast<NamedDecl>(DC);
1258 void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1259 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1260 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1261 // been made more painfully obvious by the refactor that introduced this
1262 // function, but it is possible that the incoming argument can be
1263 // eliminated. If it truly cannot be (for example, there is some reentrancy
1264 // issue I am not seeing yet), then there should at least be a clarifying
1265 // comment somewhere.
1266 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
1267 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1268 Diags.getCurrentDiagID())) {
1269 case DiagnosticIDs::SFINAE_Report:
1270 // We'll report the diagnostic below.
1273 case DiagnosticIDs::SFINAE_SubstitutionFailure:
1274 // Count this failure so that we know that template argument deduction
1278 // Make a copy of this suppressed diagnostic and store it with the
1279 // template-deduction information.
1280 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1281 Diagnostic DiagInfo(&Diags);
1282 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1283 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1286 Diags.setLastDiagnosticIgnored();
1290 case DiagnosticIDs::SFINAE_AccessControl: {
1291 // Per C++ Core Issue 1170, access control is part of SFINAE.
1292 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
1293 // make access control a part of SFINAE for the purposes of checking
1295 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
1298 SourceLocation Loc = Diags.getCurrentDiagLoc();
1300 // Suppress this diagnostic.
1303 // Make a copy of this suppressed diagnostic and store it with the
1304 // template-deduction information.
1305 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1306 Diagnostic DiagInfo(&Diags);
1307 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1308 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1311 Diags.setLastDiagnosticIgnored();
1314 // Now the diagnostic state is clear, produce a C++98 compatibility
1316 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
1318 // The last diagnostic which Sema produced was ignored. Suppress any
1319 // notes attached to it.
1320 Diags.setLastDiagnosticIgnored();
1324 case DiagnosticIDs::SFINAE_Suppress:
1325 // Make a copy of this suppressed diagnostic and store it with the
1326 // template-deduction information;
1328 Diagnostic DiagInfo(&Diags);
1329 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
1330 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1333 // Suppress this diagnostic.
1334 Diags.setLastDiagnosticIgnored();
1340 // Copy the diagnostic printing policy over the ASTContext printing policy.
1341 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
1342 Context.setPrintingPolicy(getPrintingPolicy());
1344 // Emit the diagnostic.
1345 if (!Diags.EmitCurrentDiagnostic())
1348 // If this is not a note, and we're in a template instantiation
1349 // that is different from the last template instantiation where
1350 // we emitted an error, print a template instantiation
1352 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1353 PrintContextStack();
1356 Sema::SemaDiagnosticBuilder
1357 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1358 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1364 // Print notes showing how we can reach FD starting from an a priori
1365 // known-callable function.
1366 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1367 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1368 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1369 DiagnosticBuilder Builder(
1370 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1371 Builder << FnIt->second.FD;
1372 Builder.setForceEmit();
1374 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1378 // Emit any deferred diagnostics for FD and erase them from the map in which
1380 static void emitDeferredDiags(Sema &S, FunctionDecl *FD) {
1381 auto It = S.DeviceDeferredDiags.find(FD);
1382 if (It == S.DeviceDeferredDiags.end())
1384 bool HasWarningOrError = false;
1385 for (PartialDiagnosticAt &PDAt : It->second) {
1386 const SourceLocation &Loc = PDAt.first;
1387 const PartialDiagnostic &PD = PDAt.second;
1388 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1389 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1390 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1391 Builder.setForceEmit();
1394 S.DeviceDeferredDiags.erase(It);
1396 // FIXME: Should this be called after every warning/error emitted in the loop
1397 // above, instead of just once per function? That would be consistent with
1398 // how we handle immediate errors, but it also seems like a bit much.
1399 if (HasWarningOrError)
1400 emitCallStackNotes(S, FD);
1403 // In CUDA, there are some constructs which may appear in semantically-valid
1404 // code, but trigger errors if we ever generate code for the function in which
1405 // they appear. Essentially every construct you're not allowed to use on the
1406 // device falls into this category, because you are allowed to use these
1407 // constructs in a __host__ __device__ function, but only if that function is
1408 // never codegen'ed on the device.
1410 // To handle semantic checking for these constructs, we keep track of the set of
1411 // functions we know will be emitted, either because we could tell a priori that
1412 // they would be emitted, or because they were transitively called by a
1413 // known-emitted function.
1415 // We also keep a partial call graph of which not-known-emitted functions call
1416 // which other not-known-emitted functions.
1418 // When we see something which is illegal if the current function is emitted
1419 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1420 // CheckCUDACall), we first check if the current function is known-emitted. If
1421 // so, we immediately output the diagnostic.
1423 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1424 // until we discover that the function is known-emitted, at which point we take
1425 // it out of this map and emit the diagnostic.
1427 Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1428 unsigned DiagID, FunctionDecl *Fn,
1430 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1431 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1436 case K_ImmediateWithCallStack:
1437 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1440 assert(Fn && "Must have a function to attach the deferred diag to.");
1441 auto &Diags = S.DeviceDeferredDiags[Fn];
1442 PartialDiagId.emplace(Diags.size());
1443 Diags.emplace_back(Loc, S.PDiag(DiagID));
1448 Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1449 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1450 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1451 PartialDiagId(D.PartialDiagId) {
1452 // Clean the previous diagnostics.
1453 D.ShowCallStack = false;
1454 D.ImmediateDiag.reset();
1455 D.PartialDiagId.reset();
1458 Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1459 if (ImmediateDiag) {
1460 // Emit our diagnostic and, if it was a warning or error, output a callstack
1461 // if Fn isn't a priori known-emitted.
1462 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1463 DiagID, Loc) >= DiagnosticsEngine::Warning;
1464 ImmediateDiag.reset(); // Emit the immediate diag.
1465 if (IsWarningOrError && ShowCallStack)
1466 emitCallStackNotes(S, Fn);
1468 assert((!PartialDiagId || ShowCallStack) &&
1469 "Must always show call stack for deferred diags.");
1473 // Indicate that this function (and thus everything it transtively calls) will
1474 // be codegen'ed, and emit any deferred diagnostics on this function and its
1475 // (transitive) callees.
1476 void Sema::markKnownEmitted(
1477 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1478 SourceLocation OrigLoc,
1479 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1480 // Nothing to do if we already know that FD is emitted.
1481 if (IsKnownEmitted(S, OrigCallee)) {
1482 assert(!S.DeviceCallGraph.count(OrigCallee));
1486 // We've just discovered that OrigCallee is known-emitted. Walk our call
1487 // graph to see what else we can now discover also must be emitted.
1490 FunctionDecl *Caller;
1491 FunctionDecl *Callee;
1494 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1495 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1496 Seen.insert(OrigCallee);
1497 while (!Worklist.empty()) {
1498 CallInfo C = Worklist.pop_back_val();
1499 assert(!IsKnownEmitted(S, C.Callee) &&
1500 "Worklist should not contain known-emitted functions.");
1501 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1502 emitDeferredDiags(S, C.Callee);
1504 // If this is a template instantiation, explore its callgraph as well:
1505 // Non-dependent calls are part of the template's callgraph, while dependent
1506 // calls are part of to the instantiation's call graph.
1507 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1508 FunctionDecl *TemplFD = Templ->getAsFunction();
1509 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1510 Seen.insert(TemplFD);
1512 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1516 // Add all functions called by Callee to our worklist.
1517 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1518 if (CGIt == S.DeviceCallGraph.end())
1521 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1523 FunctionDecl *NewCallee = FDLoc.first;
1524 SourceLocation CallLoc = FDLoc.second;
1525 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1527 Seen.insert(NewCallee);
1529 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1532 // C.Callee is now known-emitted, so we no longer need to maintain its list
1533 // of callees in DeviceCallGraph.
1534 S.DeviceCallGraph.erase(CGIt);
1538 Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
1539 if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
1540 return diagIfOpenMPDeviceCode(Loc, DiagID);
1541 if (getLangOpts().CUDA)
1542 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1543 : CUDADiagIfHostCode(Loc, DiagID);
1544 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1545 getCurFunctionDecl(), *this);
1548 /// Looks through the macro-expansion chain for the given
1549 /// location, looking for a macro expansion with the given name.
1550 /// If one is found, returns true and sets the location to that
1552 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
1553 SourceLocation loc = locref;
1554 if (!loc.isMacroID()) return false;
1556 // There's no good way right now to look at the intermediate
1557 // expansions, so just jump to the expansion location.
1558 loc = getSourceManager().getExpansionLoc(loc);
1560 // If that's written with the name, stop here.
1561 SmallVector<char, 16> buffer;
1562 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1569 /// Determines the active Scope associated with the given declaration
1572 /// This routine maps a declaration context to the active Scope object that
1573 /// represents that declaration context in the parser. It is typically used
1574 /// from "scope-less" code (e.g., template instantiation, lazy creation of
1575 /// declarations) that injects a name for name-lookup purposes and, therefore,
1576 /// must update the Scope.
1578 /// \returns The scope corresponding to the given declaraion context, or NULL
1579 /// if no such scope is open.
1580 Scope *Sema::getScopeForContext(DeclContext *Ctx) {
1585 Ctx = Ctx->getPrimaryContext();
1586 for (Scope *S = getCurScope(); S; S = S->getParent()) {
1587 // Ignore scopes that cannot have declarations. This is important for
1588 // out-of-line definitions of static class members.
1589 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
1590 if (DeclContext *Entity = S->getEntity())
1591 if (Ctx == Entity->getPrimaryContext())
1598 /// Enter a new function scope
1599 void Sema::PushFunctionScope() {
1600 if (FunctionScopes.empty() && CachedFunctionScope) {
1601 // Use CachedFunctionScope to avoid allocating memory when possible.
1602 CachedFunctionScope->Clear();
1603 FunctionScopes.push_back(CachedFunctionScope.release());
1605 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
1607 if (LangOpts.OpenMP)
1608 pushOpenMPFunctionRegion();
1611 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
1612 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
1613 BlockScope, Block));
1616 LambdaScopeInfo *Sema::PushLambdaScope() {
1617 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1618 FunctionScopes.push_back(LSI);
1622 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1623 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1624 LSI->AutoTemplateParameterDepth = Depth;
1628 "Remove assertion if intentionally called in a non-lambda context.");
1631 // Check that the type of the VarDecl has an accessible copy constructor and
1632 // resolve its destructor's exception specification.
1633 static void checkEscapingByref(VarDecl *VD, Sema &S) {
1634 QualType T = VD->getType();
1635 EnterExpressionEvaluationContext scope(
1636 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1637 SourceLocation Loc = VD->getLocation();
1639 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
1640 ExprResult Result = S.PerformMoveOrCopyInitialization(
1641 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1642 VarRef, /*AllowNRVO=*/true);
1643 if (!Result.isInvalid()) {
1644 Result = S.MaybeCreateExprWithCleanups(Result);
1645 Expr *Init = Result.getAs<Expr>();
1646 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1649 // The destructor's exception specification is needed when IRGen generates
1650 // block copy/destroy functions. Resolve it here.
1651 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1652 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1653 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1654 S.ResolveExceptionSpec(Loc, FPT);
1658 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1659 // Set the EscapingByref flag of __block variables captured by
1661 for (const BlockDecl *BD : FSI.Blocks) {
1662 for (const BlockDecl::Capture &BC : BD->captures()) {
1663 VarDecl *VD = BC.getVariable();
1664 if (VD->hasAttr<BlocksAttr>()) {
1665 // Nothing to do if this is a __block variable captured by a
1666 // non-escaping block.
1667 if (BD->doesNotEscape())
1669 VD->setEscapingByref();
1671 // Check whether the captured variable is or contains an object of
1672 // non-trivial C union type.
1673 QualType CapType = BC.getVariable()->getType();
1674 if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||
1675 CapType.hasNonTrivialToPrimitiveCopyCUnion())
1676 S.checkNonTrivialCUnion(BC.getVariable()->getType(),
1677 BD->getCaretLocation(),
1678 Sema::NTCUC_BlockCapture,
1679 Sema::NTCUK_Destruct|Sema::NTCUK_Copy);
1683 for (VarDecl *VD : FSI.ByrefBlockVars) {
1684 // __block variables might require us to capture a copy-initializer.
1685 if (!VD->isEscapingByref())
1687 // It's currently invalid to ever have a __block variable with an
1688 // array type; should we diagnose that here?
1689 // Regardless, we don't want to ignore array nesting when
1690 // constructing this copy.
1691 if (VD->getType()->isStructureOrClassType())
1692 checkEscapingByref(VD, S);
1696 /// Pop a function (or block or lambda or captured region) scope from the stack.
1698 /// \param WP The warning policy to use for CFG-based warnings, or null if such
1699 /// warnings should not be produced.
1700 /// \param D The declaration corresponding to this function scope, if producing
1701 /// CFG-based warnings.
1702 /// \param BlockType The type of the block expression, if D is a BlockDecl.
1703 Sema::PoppedFunctionScopePtr
1704 Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1705 const Decl *D, QualType BlockType) {
1706 assert(!FunctionScopes.empty() && "mismatched push/pop!");
1708 markEscapingByrefs(*FunctionScopes.back(), *this);
1710 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1711 PoppedFunctionScopeDeleter(this));
1713 if (LangOpts.OpenMP)
1714 popOpenMPFunctionRegion(Scope.get());
1716 // Issue any analysis-based warnings.
1718 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
1720 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1721 Diag(PUD.Loc, PUD.PD);
1726 void Sema::PoppedFunctionScopeDeleter::
1727 operator()(sema::FunctionScopeInfo *Scope) const {
1728 // Stash the function scope for later reuse if it's for a normal function.
1729 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1730 Self->CachedFunctionScope.reset(Scope);
1735 void Sema::PushCompoundScope(bool IsStmtExpr) {
1736 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
1739 void Sema::PopCompoundScope() {
1740 FunctionScopeInfo *CurFunction = getCurFunction();
1741 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1743 CurFunction->CompoundScopes.pop_back();
1746 /// Determine whether any errors occurred within this function/method/
1748 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1749 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
1752 void Sema::setFunctionHasBranchIntoScope() {
1753 if (!FunctionScopes.empty())
1754 FunctionScopes.back()->setHasBranchIntoScope();
1757 void Sema::setFunctionHasBranchProtectedScope() {
1758 if (!FunctionScopes.empty())
1759 FunctionScopes.back()->setHasBranchProtectedScope();
1762 void Sema::setFunctionHasIndirectGoto() {
1763 if (!FunctionScopes.empty())
1764 FunctionScopes.back()->setHasIndirectGoto();
1767 BlockScopeInfo *Sema::getCurBlock() {
1768 if (FunctionScopes.empty())
1771 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1772 if (CurBSI && CurBSI->TheDecl &&
1773 !CurBSI->TheDecl->Encloses(CurContext)) {
1774 // We have switched contexts due to template instantiation.
1775 assert(!CodeSynthesisContexts.empty());
1782 FunctionScopeInfo *Sema::getEnclosingFunction() const {
1783 if (FunctionScopes.empty())
1786 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1787 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1789 return FunctionScopes[e];
1794 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
1795 if (FunctionScopes.empty())
1798 auto I = FunctionScopes.rbegin();
1799 if (IgnoreNonLambdaCapturingScope) {
1800 auto E = FunctionScopes.rend();
1801 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
1806 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
1807 if (CurLSI && CurLSI->Lambda &&
1808 !CurLSI->Lambda->Encloses(CurContext)) {
1809 // We have switched contexts due to template instantiation.
1810 assert(!CodeSynthesisContexts.empty());
1816 // We have a generic lambda if we parsed auto parameters, or we have
1817 // an associated template parameter list.
1818 LambdaScopeInfo *Sema::getCurGenericLambda() {
1819 if (LambdaScopeInfo *LSI = getCurLambda()) {
1820 return (LSI->TemplateParams.size() ||
1821 LSI->GLTemplateParameterList) ? LSI : nullptr;
1827 void Sema::ActOnComment(SourceRange Comment) {
1828 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1829 SourceMgr.isInSystemHeader(Comment.getBegin()))
1831 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
1832 if (RC.isAlmostTrailingComment()) {
1833 SourceRange MagicMarkerRange(Comment.getBegin(),
1834 Comment.getBegin().getLocWithOffset(3));
1835 StringRef MagicMarkerText;
1836 switch (RC.getKind()) {
1837 case RawComment::RCK_OrdinaryBCPL:
1838 MagicMarkerText = "///<";
1840 case RawComment::RCK_OrdinaryC:
1841 MagicMarkerText = "/**<";
1844 llvm_unreachable("if this is an almost Doxygen comment, "
1845 "it should be ordinary");
1847 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1848 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1850 Context.addComment(RC);
1853 // Pin this vtable to this file.
1854 ExternalSemaSource::~ExternalSemaSource() {}
1856 void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
1857 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
1859 void ExternalSemaSource::ReadKnownNamespaces(
1860 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
1863 void ExternalSemaSource::ReadUndefinedButUsed(
1864 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
1866 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1867 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1869 /// Figure out if an expression could be turned into a call.
1871 /// Use this when trying to recover from an error where the programmer may have
1872 /// written just the name of a function instead of actually calling it.
1874 /// \param E - The expression to examine.
1875 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1876 /// with no arguments, this parameter is set to the type returned by such a
1877 /// call; otherwise, it is set to an empty QualType.
1878 /// \param OverloadSet - If the expression is an overloaded function
1879 /// name, this parameter is populated with the decls of the various overloads.
1880 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1881 UnresolvedSetImpl &OverloadSet) {
1882 ZeroArgCallReturnTy = QualType();
1883 OverloadSet.clear();
1885 const OverloadExpr *Overloads = nullptr;
1886 bool IsMemExpr = false;
1887 if (E.getType() == Context.OverloadTy) {
1888 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
1890 // Ignore overloads that are pointer-to-member constants.
1891 if (FR.HasFormOfMemberPointer)
1894 Overloads = FR.Expression;
1895 } else if (E.getType() == Context.BoundMemberTy) {
1896 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
1900 bool Ambiguous = false;
1904 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1905 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
1906 OverloadSet.addDecl(*it);
1908 // Check whether the function is a non-template, non-member which takes no
1912 if (const FunctionDecl *OverloadDecl
1913 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
1914 if (OverloadDecl->getMinRequiredArguments() == 0) {
1915 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1916 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1917 OverloadDecl->isCPUSpecificMultiVersion()))) {
1918 ZeroArgCallReturnTy = QualType();
1921 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
1922 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1923 OverloadDecl->isCPUSpecificMultiVersion();
1929 // If it's not a member, use better machinery to try to resolve the call
1931 return !ZeroArgCallReturnTy.isNull();
1934 // Attempt to call the member with no arguments - this will correctly handle
1935 // member templates with defaults/deduction of template arguments, overloads
1936 // with default arguments, etc.
1937 if (IsMemExpr && !E.isTypeDependent()) {
1938 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1939 getDiagnostics().setSuppressAllDiagnostics(true);
1940 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1941 None, SourceLocation());
1942 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1944 ZeroArgCallReturnTy = R.get()->getType();
1950 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
1951 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1952 if (Fun->getMinRequiredArguments() == 0)
1953 ZeroArgCallReturnTy = Fun->getReturnType();
1958 // We don't have an expression that's convenient to get a FunctionDecl from,
1959 // but we can at least check if the type is "function of 0 arguments".
1960 QualType ExprTy = E.getType();
1961 const FunctionType *FunTy = nullptr;
1962 QualType PointeeTy = ExprTy->getPointeeType();
1963 if (!PointeeTy.isNull())
1964 FunTy = PointeeTy->getAs<FunctionType>();
1966 FunTy = ExprTy->getAs<FunctionType>();
1968 if (const FunctionProtoType *FPT =
1969 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
1970 if (FPT->getNumParams() == 0)
1971 ZeroArgCallReturnTy = FunTy->getReturnType();
1977 /// Give notes for a set of overloads.
1979 /// A companion to tryExprAsCall. In cases when the name that the programmer
1980 /// wrote was an overloaded function, we may be able to make some guesses about
1981 /// plausible overloads based on their return types; such guesses can be handed
1982 /// off to this method to be emitted as notes.
1984 /// \param Overloads - The overloads to note.
1985 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1986 /// -fshow-overloads=best, this is the location to attach to the note about too
1987 /// many candidates. Typically this will be the location of the original
1988 /// ill-formed expression.
1989 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1990 const SourceLocation FinalNoteLoc) {
1991 int ShownOverloads = 0;
1992 int SuppressedOverloads = 0;
1993 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1994 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1995 // FIXME: Magic number for max shown overloads stolen from
1996 // OverloadCandidateSet::NoteCandidates.
1997 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
1998 ++SuppressedOverloads;
2002 NamedDecl *Fn = (*It)->getUnderlyingDecl();
2003 // Don't print overloads for non-default multiversioned functions.
2004 if (const auto *FD = Fn->getAsFunction()) {
2005 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
2006 !FD->getAttr<TargetAttr>()->isDefaultVersion())
2009 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
2013 if (SuppressedOverloads)
2014 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2015 << SuppressedOverloads;
2018 static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2019 const UnresolvedSetImpl &Overloads,
2020 bool (*IsPlausibleResult)(QualType)) {
2021 if (!IsPlausibleResult)
2022 return noteOverloads(S, Overloads, Loc);
2024 UnresolvedSet<2> PlausibleOverloads;
2025 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2026 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2027 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
2028 QualType OverloadResultTy = OverloadDecl->getReturnType();
2029 if (IsPlausibleResult(OverloadResultTy))
2030 PlausibleOverloads.addDecl(It.getDecl());
2032 noteOverloads(S, PlausibleOverloads, Loc);
2035 /// Determine whether the given expression can be called by just
2036 /// putting parentheses after it. Notably, expressions with unary
2037 /// operators can't be because the unary operator will start parsing
2038 /// outside the call.
2039 static bool IsCallableWithAppend(Expr *E) {
2040 E = E->IgnoreImplicit();
2041 return (!isa<CStyleCastExpr>(E) &&
2042 !isa<UnaryOperator>(E) &&
2043 !isa<BinaryOperator>(E) &&
2044 !isa<CXXOperatorCallExpr>(E));
2047 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2048 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2049 E = UO->getSubExpr();
2051 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2052 if (ULE->getNumDecls() == 0)
2055 const NamedDecl *ND = *ULE->decls_begin();
2056 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2057 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2062 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2064 bool (*IsPlausibleResult)(QualType)) {
2065 SourceLocation Loc = E.get()->getExprLoc();
2066 SourceRange Range = E.get()->getSourceRange();
2068 QualType ZeroArgCallTy;
2069 UnresolvedSet<4> Overloads;
2070 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
2071 !ZeroArgCallTy.isNull() &&
2072 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2073 // At this point, we know E is potentially callable with 0
2074 // arguments and that it returns something of a reasonable type,
2075 // so we can emit a fixit and carry on pretending that E was
2076 // actually a CallExpr.
2077 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
2078 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2079 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2080 << (IsCallableWithAppend(E.get())
2081 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2084 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2086 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2088 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
2089 Range.getEnd().getLocWithOffset(1));
2093 if (!ForceComplain) return false;
2095 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2096 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2098 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
2103 IdentifierInfo *Sema::getSuperIdentifier() const {
2105 Ident_super = &Context.Idents.get("super");
2109 IdentifierInfo *Sema::getFloat128Identifier() const {
2110 if (!Ident___float128)
2111 Ident___float128 = &Context.Idents.get("__float128");
2112 return Ident___float128;
2115 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
2116 CapturedRegionKind K) {
2117 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
2118 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2119 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
2120 CSI->ReturnType = Context.VoidTy;
2121 FunctionScopes.push_back(CSI);
2124 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2125 if (FunctionScopes.empty())
2128 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2131 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2132 Sema::getMismatchingDeleteExpressions() const {
2136 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2139 llvm::SmallVector<StringRef, 1> Exts;
2140 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2141 auto CanT = T.getCanonicalType().getTypePtr();
2142 for (auto &I : Exts)
2143 OpenCLTypeExtMap[CanT].insert(I.str());
2146 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2147 llvm::SmallVector<StringRef, 1> Exts;
2148 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2151 for (auto &I : Exts)
2152 OpenCLDeclExtMap[FD].insert(I.str());
2155 void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2156 if (CurrOpenCLExtension.empty())
2158 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2161 void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2162 if (CurrOpenCLExtension.empty())
2164 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2167 std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2168 if (!OpenCLDeclExtMap.empty())
2169 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2174 std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2175 if (!OpenCLTypeExtMap.empty())
2176 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2181 template <typename T, typename MapT>
2182 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2183 std::string ExtensionNames = "";
2184 auto Loc = Map.find(FDT);
2186 for (auto const& I : Loc->second) {
2187 ExtensionNames += I;
2188 ExtensionNames += " ";
2190 ExtensionNames.pop_back();
2192 return ExtensionNames;
2195 bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2196 auto Loc = OpenCLDeclExtMap.find(FD);
2197 if (Loc == OpenCLDeclExtMap.end())
2199 for (auto &I : Loc->second) {
2200 if (!getOpenCLOptions().isEnabled(I))
2206 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2207 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2208 DiagInfoT DiagInfo, MapT &Map,
2210 SourceRange SrcRange) {
2211 auto Loc = Map.find(D);
2212 if (Loc == Map.end())
2214 bool Disabled = false;
2215 for (auto &I : Loc->second) {
2216 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2217 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2225 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2226 // Check extensions for declared types.
2227 Decl *Decl = nullptr;
2228 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2229 Decl = TypedefT->getDecl();
2230 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2231 Decl = TagT->getDecl();
2232 auto Loc = DS.getTypeSpecTypeLoc();
2234 // Check extensions for vector types.
2235 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2236 if (QT->isExtVectorType()) {
2237 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2238 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2241 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2244 // Check extensions for builtin types.
2245 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2246 QT, OpenCLTypeExtMap);
2249 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2250 IdentifierInfo *FnName = D.getIdentifier();
2251 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
2252 OpenCLDeclExtMap, 1, D.getSourceRange());