From 5815a311050ae218ebcda53adeee24ed96851943 Mon Sep 17 00:00:00 2001 From: cor3ntin Date: Mon, 27 Jan 2025 22:21:48 +0100 Subject: [PATCH] [Clang] call HandleImmediateInvocation before checking for immediate escacalating expressions (#124414) HandleImmediateInvocation can call MarkExpressionAsImmediateEscalating and should always be called before CheckImmediateEscalatingFunctionDefinition. However, we were not doing that in `ActFunctionBody`. We simply move CheckImmediateEscalatingFunctionDefinition to PopExpressionEvaluationContext. Fixes #119046 --- clang/docs/ReleaseNotes.rst | 1 + clang/include/clang/Sema/Sema.h | 6 ++-- clang/lib/Sema/SemaDecl.cpp | 1 - clang/lib/Sema/SemaExpr.cpp | 3 ++ clang/test/CodeGenCXX/gh119046.cpp | 32 +++++++++++++++++++ .../SemaCXX/cxx2b-consteval-propagate.cpp | 17 ++++++++++ 6 files changed, 56 insertions(+), 4 deletions(-) create mode 100644 clang/test/CodeGenCXX/gh119046.cpp diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index af3632322b84538..8b04f172946df1a 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -1003,6 +1003,7 @@ Bug Fixes to C++ Support - Fixed assertions or false compiler diagnostics in the case of C++ modules for lambda functions or inline friend functions defined inside templates (#GH122493). - Clang now rejects declaring an alias template with the same name as its template parameter. (#GH123423) +- Fix that some dependent immediate expressions did not cause immediate escalation (#GH119046) - Fixed the rejection of valid code when referencing an enumerator of an unscoped enum member with a prior declaration. (#GH124405) - Fixed immediate escalation of non-dependent expressions. (#GH123405) - Fix type of expression when calling a template which returns an ``__array_rank`` querying a type depending on a diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 528304409b80923..f1d1e2e567193f1 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -13139,10 +13139,10 @@ class Sema final : public SemaBase { ~SynthesizedFunctionScope() { if (PushedCodeSynthesisContext) S.popCodeSynthesisContext(); - if (auto *FD = dyn_cast(S.CurContext)) { + + if (auto *FD = dyn_cast(S.CurContext)) FD->setWillHaveBody(false); - S.CheckImmediateEscalatingFunctionDefinition(FD, S.getCurFunction()); - } + S.PopExpressionEvaluationContext(); S.PopFunctionScopeInfo(); } diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index fe68eadc951b5ff..accef4c5d5d9168 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -16019,7 +16019,6 @@ Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, if (!FD->isDeletedAsWritten()) FD->setBody(Body); FD->setWillHaveBody(false); - CheckImmediateEscalatingFunctionDefinition(FD, FSI); if (getLangOpts().CPlusPlus14) { if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() && diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp index 176627c3df37c67..e098b21045f01da 100644 --- a/clang/lib/Sema/SemaExpr.cpp +++ b/clang/lib/Sema/SemaExpr.cpp @@ -17881,6 +17881,9 @@ void Sema::PopExpressionEvaluationContext() { WarnOnPendingNoDerefs(Rec); HandleImmediateInvocations(*this, Rec); + if (auto *FD = dyn_cast(CurContext); FD && getCurFunction()) + CheckImmediateEscalatingFunctionDefinition(FD, getCurFunction()); + // Warn on any volatile-qualified simple-assignments that are not discarded- // value expressions nor unevaluated operands (those cases get removed from // this list by CheckUnusedVolatileAssignment). diff --git a/clang/test/CodeGenCXX/gh119046.cpp b/clang/test/CodeGenCXX/gh119046.cpp new file mode 100644 index 000000000000000..cad76879f08624b --- /dev/null +++ b/clang/test/CodeGenCXX/gh119046.cpp @@ -0,0 +1,32 @@ +// RUN: %clang_cc1 -std=c++2a -triple x86_64-elf-gnu %s -emit-llvm -o - | FileCheck %s + +struct S { + consteval void operator()() {} +}; + +template +constexpr void dispatch(Fn fn) { + fn(); +} + +template +struct value_visitor { + constexpr void operator()() { visitor(); } + Visitor&& visitor; +}; + +template +constexpr auto make_dispatch() { + return dispatch>; +} + +template +constexpr void visit(Visitor&&) { + make_dispatch(); +} + +void f() { visit(S{}); } + +// CHECK: define {{.*}} @_Z1fv +// CHECK-NOT: define {{.*}} @_Z5visitI1SEvOT_ +// CHECK-NOT: define {{.*}} @_Z13make_dispatchI1SEDav diff --git a/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp b/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp index 05904d9ade067f1..e83e03da54f788d 100644 --- a/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp +++ b/clang/test/SemaCXX/cxx2b-consteval-propagate.cpp @@ -529,6 +529,23 @@ D d(0); // expected-note {{in implicit initialization for inherited constructor } +namespace GH119046 { + +template constexpr auto tfn(int) { + return (unsigned long long)(&Cls::sfn); + //expected-note@-1 {{'tfn' is an immediate function because its body evaluates the address of a consteval function 'sfn'}} +}; +struct S { static consteval void sfn() {} }; + +int f() { + int a = 0; // expected-note{{declared here}} + return tfn(a); + //expected-error@-1 {{call to immediate function 'GH119046::tfn' is not a constant expression}} + //expected-note@-2 {{read of non-const variable 'a' is not allowed in a constant expression}} +} + +} + namespace GH123405 { consteval void fn() {}