Author: Eli Friedman Date: 2025-07-08T14:47:04-07:00 New Revision: 6a993264ee0105da32a6a57fb077796076cf6bf4
URL: https://github.com/llvm/llvm-project/commit/6a993264ee0105da32a6a57fb077796076cf6bf4 DIFF: https://github.com/llvm/llvm-project/commit/6a993264ee0105da32a6a57fb077796076cf6bf4.diff LOG: [clang] Consistently handle consteval constructors for variables. (#144970) 443377a9d1a8d4a69a317a1a892184c59dd0aec6 handled simple variable definitions, but it didn't handle uninitialized variables with a consteval constructor, and it didn't handle template instantiation. Fixes #135281 . Added: Modified: clang/docs/ReleaseNotes.rst clang/include/clang/Sema/Sema.h clang/lib/Parse/ParseDecl.cpp clang/lib/Sema/SemaCoroutine.cpp clang/lib/Sema/SemaDeclCXX.cpp clang/lib/Sema/SemaExpr.cpp clang/lib/Sema/SemaTemplateInstantiateDecl.cpp clang/test/SemaCXX/cxx2b-consteval-propagate.cpp Removed: ################################################################################ diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index a919f3a71c9cf..8b4f9229c4463 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -920,6 +920,9 @@ Bug Fixes to C++ Support - Correctly handle allocations in the condition of a ``if constexpr``.(#GH120197) (#GH134820) - Fixed a crash when handling invalid member using-declaration in C++20+ mode. (#GH63254) - Fix a crash when trying to instantiate an ambiguous specialization. (#GH51866) +- Improved handling of variables with ``consteval`` constructors, to + consistently treat the initializer as manifestly constant-evaluated. + (#GH135281) Bug Fixes to AST Handling ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index b281b1cfef96a..a21836dffb0e6 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -6761,6 +6761,7 @@ class Sema final : public SemaBase { EK_Decltype, EK_TemplateArgument, EK_AttrArgument, + EK_VariableInit, EK_Other } ExprContext; diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp index 7e739e09b15e8..c34a1fb6004a9 100644 --- a/clang/lib/Parse/ParseDecl.cpp +++ b/clang/lib/Parse/ParseDecl.cpp @@ -2710,6 +2710,7 @@ Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes( break; } case InitKind::Uninitialized: { + InitializerScopeRAII InitScope(*this, D, ThisDecl); Actions.ActOnUninitializedDecl(ThisDecl); break; } diff --git a/clang/lib/Sema/SemaCoroutine.cpp b/clang/lib/Sema/SemaCoroutine.cpp index a1389c6c034b1..d193a33f22393 100644 --- a/clang/lib/Sema/SemaCoroutine.cpp +++ b/clang/lib/Sema/SemaCoroutine.cpp @@ -783,7 +783,8 @@ static bool checkSuspensionContext(Sema &S, SourceLocation Loc, const auto ExprContext = S.currentEvaluationContext().ExprContext; const bool BadContext = S.isUnevaluatedContext() || - ExprContext != Sema::ExpressionEvaluationContextRecord::EK_Other; + (ExprContext != Sema::ExpressionEvaluationContextRecord::EK_Other && + ExprContext != Sema::ExpressionEvaluationContextRecord::EK_VariableInit); if (BadContext) { S.Diag(Loc, diag::err_coroutine_unevaluated_context) << Keyword; return false; diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index f0247f865ba40..a49a8abb677c5 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -18892,7 +18892,8 @@ void Sema::ActOnCXXEnterDeclInitializer(Scope *S, Decl *D) { EnterDeclaratorContext(S, D->getDeclContext()); PushExpressionEvaluationContext( - ExpressionEvaluationContext::PotentiallyEvaluated, D); + ExpressionEvaluationContext::PotentiallyEvaluated, D, + ExpressionEvaluationContextRecord::EK_VariableInit); } void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) { @@ -18901,29 +18902,6 @@ void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) { if (S && D->isOutOfLine()) ExitDeclaratorContext(S); - if (getLangOpts().CPlusPlus23) { - // An expression or conversion is 'manifestly constant-evaluated' if it is: - // [...] - // - the initializer of a variable that is usable in constant expressions or - // has constant initialization. - if (auto *VD = dyn_cast<VarDecl>(D); - VD && (VD->isUsableInConstantExpressions(Context) || - VD->hasConstantInitialization())) { - // An expression or conversion is in an 'immediate function context' if it - // is potentially evaluated and either: - // [...] - // - it is a subexpression of a manifestly constant-evaluated expression - // or conversion. - ExprEvalContexts.back().InImmediateFunctionContext = true; - } - } - - // Unless the initializer is in an immediate function context (as determined - // above), this will evaluate all contained immediate function calls as - // constant expressions. If the initializer IS an immediate function context, - // the initializer has been determined to be a constant expression, and all - // such evaluations will be elided (i.e., as if we "knew the whole time" that - // it was a constant expression). PopExpressionEvaluationContext(); } diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 3c3d29c415249..01df1913339d9 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -17934,6 +17934,25 @@ HandleImmediateInvocations(Sema &SemaRef, Rec.isImmediateFunctionContext() || SemaRef.RebuildingImmediateInvocation) return; + // An expression or conversion is 'manifestly constant-evaluated' if it is: + // [...] + // - the initializer of a variable that is usable in constant expressions or + // has constant initialization. + if (SemaRef.getLangOpts().CPlusPlus23 && + Rec.ExprContext == + Sema::ExpressionEvaluationContextRecord::EK_VariableInit) { + auto *VD = cast<VarDecl>(Rec.ManglingContextDecl); + if (VD->isUsableInConstantExpressions(SemaRef.Context) || + VD->hasConstantInitialization()) { + // An expression or conversion is in an 'immediate function context' if it + // is potentially evaluated and either: + // [...] + // - it is a subexpression of a manifestly constant-evaluated expression + // or conversion. + return; + } + } + /// When we have more than 1 ImmediateInvocationCandidates or previously /// failed immediate invocations, we need to check for nested /// ImmediateInvocationCandidates in order to avoid duplicate diagnostics. diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index c6633cbe51cef..70a4c159f9805 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -6103,7 +6103,8 @@ void Sema::InstantiateVariableInitializer( ContextRAII SwitchContext(*this, Var->getDeclContext()); EnterExpressionEvaluationContext Evaluated( - *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var); + *this, Sema::ExpressionEvaluationContext::PotentiallyEvaluated, Var, + ExpressionEvaluationContextRecord::EK_VariableInit); currentEvaluationContext().InLifetimeExtendingContext = parentEvaluationContext().InLifetimeExtendingContext; currentEvaluationContext().RebuildDefaultArgOrDefaultInit = diff --git a/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp b/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp index dd5063cb29c5b..c4cfd9398920a 100644 --- a/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp +++ b/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp @@ -576,3 +576,37 @@ int f() { //expected-note@-2 {{read of non-const variable 'a' is not allowed in a constant expression}} } } + +#if __cplusplus >= 202302L +namespace GH135281 { + struct B { + const void* p; + consteval B() : p{this} {} + }; + B b; + B b2{}; + B &&b3{}; + void f() { + static B b4; + B b5; // expected-error {{call to consteval function 'GH135281::B::B' is not a constant expression}} \ + // expected-note {{pointer to temporary is not a constant expression}} \ + // expected-note {{temporary created here}} + } + template<typename T> T temp_var_uninit; + template<typename T> T temp_var_brace_init{}; + B* b6 = &temp_var_uninit<B>; + B* b7 = &temp_var_brace_init<B>; + B* b8 = &temp_var_brace_init<B&&>; + template<typename T> void f2() { + static T b9; + T b10; // expected-error {{call to consteval function 'GH135281::B::B' is not a constant expression}} \ + // expected-note {{pointer to temporary is not a constant expression}} \ + // expected-note {{temporary created here}} + static B b11; + B b12; // expected-error 2 {{call to consteval function 'GH135281::B::B' is not a constant expression}} \ + // expected-note 2 {{pointer to temporary is not a constant expression}} \ + // expected-note 2 {{temporary created here}} + } + void (*ff)() = f2<B>; // expected-note {{instantiation of function template specialization}} +} +#endif _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
