[Clang] Fix consteval propagation for aggregates and defaulted constructors

[cor3ntin]

Summary

This patch does a few things:

• Fix aggregate initialization. When an aggregate has an initializer that is immediate-escalating, the context in which it is used automatically becomes an immediate function. The wording does that by rpretending an aggregate initialization is itself an invocation which is not really how clang works, so my previous attempt was... wrong.

• Fix initialization of defaulted constructors with immediate escalating default member initializers. The wording was silent about that case and I did not handled it fully https://cplusplus.github.io/CWG/issues/2760.html

• Fix diagnostics In some cases clang would produce additional and unhelpful diagnostics by listing the invalid references to consteval function that appear in immediate escalating functions

Fixes https://github.com/llvm/llvm-project/issues/63742

[efriedma]

Do we need CodeGen testcases here for full coverage? The testcases from the issue passed with -fsyntax-only.

---

With this patch, the following cases produce errors that don't really make sense to me:

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    constexpr SS(int yy) : y(yy) {}
};
SS s = {1};

<stdin>:6:13: error: call to consteval function 'f' is not a constant expression
    6 |     int x = f(this->y);
      |             ^
<stdin>:7:15: note: in the default initializer of 'x'
    7 |     constexpr SS(int yy) : y(yy) {}
      |               ^
<stdin>:6:5: note: declared here
    6 |     int x = f(this->y);
      |     ^
<stdin>:6:15: note: use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function
    6 |     int x = f(this->y);
      |               ^
1 error generated.

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    consteval SS(int yy) : y(yy) {}
};
SS s = {1};

<stdin>:6:13: error: cannot take address of consteval function 'f' outside of an immediate invocation
    6 |     int x = f(this->y);
      |             ^
<stdin>:1:15: note: declared here
    1 | consteval int f(int x) {
      |               ^
1 error generated.

Somehow the following is accepted, though:

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    template<typename T> constexpr SS(T yy) : y(yy) {}
};
SS s = {1};

[cor3ntin]

In D155175#4498788, @efriedma wrote:

Do we need CodeGen testcases here for full coverage? The testcases from the issue passed with -fsyntax-only.

---

With this patch, the following cases produce errors that don't really make sense to me:

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    constexpr SS(int yy) : y(yy) {}
};
SS s = {1};

<stdin>:6:13: error: call to consteval function 'f' is not a constant expression
    6 |     int x = f(this->y);
      |             ^
<stdin>:7:15: note: in the default initializer of 'x'
    7 |     constexpr SS(int yy) : y(yy) {}
      |               ^
<stdin>:6:5: note: declared here
    6 |     int x = f(this->y);
      |     ^
<stdin>:6:15: note: use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function
    6 |     int x = f(this->y);
      |               ^
1 error generated.

This seems reasonable, it's equivalent to constexpr SS(int yy) : y(yy), x(f(y)) {} = which is not a valid call of a consteval function. And the constructor is neither defaulted, nor templated, so escalation does not happen.
I agree that "use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function" isn't amazing but it's preexisting
https://godbolt.org/z/sa78bzsed

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    consteval SS(int yy) : y(yy) {}
};
SS s = {1};

<stdin>:6:13: error: cannot take address of consteval function 'f' outside of an immediate invocation
    6 |     int x = f(this->y);
      |             ^
<stdin>:1:15: note: declared here
    1 | consteval int f(int x) {
      |               ^
1 error generated.

Yup, this is not great - I think it's unrelated the degradation of error message was introduced between 15 and 16, I probably want to investigate in a separate patch, not sure yet.

Scratch that, this is a bug, see below

Somehow the following is accepted, though:

consteval int f(int x) {
    return x;
}
struct SS {
    int y;
    int x = f(this->y);
    template<typename T> constexpr SS(T yy) : y(yy) {}
};
SS s = {1};

Yes, this is bad. Thanks for finding it.
It compiles because 1 is a constant and somehow it ends up evaluating f(1) instead of f(y) - replacing 1 by a reference to a local variable produce the expected behavior. Investigating.

Scratch that previous comment, this is fine, that code is correct
SS::SS is immediate escalating because it is templated and SS::SS(1) is a valid constant expression.

There is however a separate bugs that in the non template case we do not evaluate
default members in an immediate context.
That is easy enough to fix!

[cor3ntin]

I found further issues with aggregates,
I think not supporting aggregates for now would be fine, the high bit is to fix the regressions
I did add some more info there https://github.com/cplusplus/CWG/issues/354#issuecomment-1636129255

[cor3ntin]

Fix the evaluation context of member initializers

[cor3ntin]

In D155175#4498788, @efriedma wrote:

Do we need CodeGen testcases here for full coverage? The testcases from the issue passed with -fsyntax-only.

You have something specific in mind?
The examples in the issues now lead to sema errors.

[cor3ntin]

Assert if we try to generate code for a CallExpr to an immediate function

[efriedma]

You have something specific in mind?

I was thinking something along the lines of the original testcase in 63742, which successfully compiled in 16, started producing an assertion on main, and successfully compiles with this patch.

[cor3ntin]

Add more tests for aggregates and a codegen test

[efriedma]

Test changes look fine. (I'm not really comfortable reviewing the Sema logic.)

[cor3ntin]

Revert inadvertently committed cmake changes.

[aaron.ballman]

Just to clarify, this was a regression introduced during Clang 17 development and thus this doesn't need a release note?

clang/include/clang/Sema/Sema.h

6588

clang/lib/Sema/SemaDeclCXX.cpp

2442–2443

clang/lib/Sema/SemaExpr.cpp

6222

Under what circumstances can we have a FieldDecl without a parent object? I think this can be true, right?

18439

clang/test/CodeGenCXX/cxx2c-consteval-consteval.cpp

1–2 ↗

(On Diff #541057)

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

58

Helps make it more obvious this is a continuation of the previous comment.

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

201–202

219

240

245–246

I don't have a suggestion yet on how to improve this, but this diagnostic did catch me by surprise because nothing about the declaration of SS s; makes me think "this should be a valid constant expression", so the error felt misplaced.

[Fznamznon]

clang/lib/Sema/SemaDeclCXX.cpp

2442–2443

Is there any logical value in passing FunctionScopeInfo instead of a bool flag?

clang/lib/Sema/SemaExpr.cpp

6221

Could you please describe why this change is required?

18467

I would prefer spelling type here.

[cor3ntin]

clang/lib/Sema/SemaDeclCXX.cpp

2442–2443

FYI FunctionScopeInfo is declared in sema and removing that does not seem possible.

2442–2443

in ~SynthesizedFunctionScope() we do not have a definition for it. the alternative would be to move SynthesizedFunctionScope to Sema.cpp

clang/lib/Sema/SemaExpr.cpp

6221

Sure, if we have an immediate invocation that refers to the this pointer it might need to be transformed, and that transformation will call getCurrentThisType which needs this to point to the right type

18467

that's an std::optional<ExpressionEvaluationContextRecord::InitializationContext>, I'm not sure spelling it improved readability. But i can change it!

[Fznamznon]

clang/lib/Sema/SemaExpr.cpp

18467

Uh, yeah, doesn't seem to be improving readability. NVM :)

[cor3ntin]

Address Mariya & Aaron's feedback

[cor3ntin]

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

245–246

I've improved, i hope that works for you!

[cor3ntin]

clang/include/clang/AST/RecursiveASTVisitor.h

2730–2735

Note this is one of the reasons we didn;t get better diagnostics. It's adding there assuming this was an oversight.
Indeed, i see no reason CXXDefaultInitExpr should not be traversed if CXXDefaultArgExpr should.

[cor3ntin]

Fix test name

[aaron.ballman]

clang/lib/Sema/SemaDeclCXX.cpp

2442–2443

Oh wow, good to ignore that suggestion then! :-D

clang/lib/Sema/SemaExpr.cpp

18467

Heh, I went to make the same suggestion on my last round of review, then checked to see what the actual type would be, and went "eh... probably better the way it is". I'm glad I'm not the only one! :-D

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

222

Ah, I see, because s2 is constant initialized, we *don't* hit the call to side_effect() and so this is a valid initialization. I think my brain read the code in f2() wrong previously, sorry for that!

245

Thank you for the new diagnostic wording, I think it's a good improvement! However, should the second note be on the constructor declaration as opposed to the declaration of x?

[cor3ntin]

Correctly track constructor location.

[cor3ntin]

Remove an assert (added in a previous iteration of this PR).

Unfortunately, we sometimes do emit the address of an immediate function,
after we establish the program is ill-formed - as we still proceed to code gen.

cpp

consteval int id(int i) { return i; }
constexpr int f(auto t) { 
    return t + id(t); 
}

auto b = &f<int>;

We establish taking the address of &f<int> is not possible
when exiting the evaluation context.
At this point b has an init expression, which codegen will try to emit.
Ideally we should try to remove the init all together after the fact but so far
I have not been able to do so.

[aaron.ballman]

In D155175#4518366, @cor3ntin wrote:

Remove an assert (added in a previous iteration of this PR).

Unfortunately, we sometimes do emit the address of an immediate function,
after we establish the program is ill-formed - as we still proceed to code gen.

cpp

consteval int id(int i) { return i; }
constexpr int f(auto t) { 
    return t + id(t); 
}

auto b = &f<int>;

We establish taking the address of &f<int> is not possible
when exiting the evaluation context.
At this point b has an init expression, which codegen will try to emit.
Ideally we should try to remove the init all together after the fact but so far
I have not been able to do so.

The removed code was this:

llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
                                                 llvm::Type *Ty,
                                                 bool ForVTable,
                                                 bool DontDefer,
                                              ForDefinition_t IsForDefinition) {
  assert(!cast<FunctionDecl>(GD.getDecl())->isImmediateFunction() &&
         "an immediate function should never be emitted");

which seems like very reasonable assertion to have. Should we be marking the init expression/declaration as invalid to force codegen not to run on the expression? So it's not removing the init, but is marking the declaration its attached to as invalid. CC @efriedma @rjmccall

[cor3ntin]

Should we be marking the init expression/declaration as invalid to force codegen not to run on the expression? So it's not removing the init, but is marking the declaration its attached to as invalid.

We should remove the init from the declaration entirely, the tricky part is find the declaration. I did try but so far failed. It's an issue we can track and explore separately from this PR

[aaron.ballman]

Changes LGTM as-is, I'm okay with tracking the assertion question separately. Please give @Fznamznon a chance to check that her concerns have all been addressed before landing.

[Fznamznon]

Just a couple of NITs otherwise LGTM

clang/lib/Sema/SemaDeclCXX.cpp

2506

2546

Maybe it makes sense to drop const from FD parameter instead of doing a const_cast?

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

48–49

Maybe it makes sense to print InitWithLambda::InitWithLambda so it looks same as "call to immediate function ... is not a constant expression" message and makes it more obvious.

[cor3ntin]

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

48–49

I don't disagree but for some reason default constructors are printed that way... I'd have to make the diagnostics even more complicated and it did not feel worth it.

[Fznamznon]

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

48–49

Ok, I see! Yes, I don't feel that making it more complicated is worth it too.

[cor3ntin]

• Fix FunctionDecl constness
• Replan an auto

[cor3ntin]

Rebase

clang/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(CXXBindTemporaryExpr, {})
 DEF_TRAVERSE_STMT(CXXBoolLiteralExpr, {})
 
 DEF_TRAVERSE_STMT(CXXDefaultArgExpr, {
   if (getDerived().shouldVisitImplicitCode())
     TRY_TO(TraverseStmt(S->getExpr()));
 })
 
-DEF_TRAVERSE_STMT(CXXDefaultInitExpr, {})
+DEF_TRAVERSE_STMT(CXXDefaultInitExpr, {
+  if (getDerived().shouldVisitImplicitCode())
+    TRY_TO(TraverseStmt(S->getExpr()));
+})
+
 DEF_TRAVERSE_STMT(CXXDeleteExpr, {})
 DEF_TRAVERSE_STMT(ExprWithCleanups, {})
 DEF_TRAVERSE_STMT(CXXInheritedCtorInitExpr, {})
 DEF_TRAVERSE_STMT(CXXNullPtrLiteralExpr, {})
 DEF_TRAVERSE_STMT(CXXStdInitializerListExpr, {})
 
 DEF_TRAVERSE_STMT(CXXPseudoDestructorExpr, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   if (TypeSourceInfo *ScopeInfo = S->getScopeTypeInfo())

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_invalid_consteval_call : Error<
   "call to %select{immediate|consteval}1 function "
   "%q0 is not a constant expression">;
 
 def err_immediate_function_used_before_definition : Error<
   "immediate function %0 used before it is defined">;
 
 def note_immediate_function_reason : Note<
-  "%0 is an immediate function because its body "
+  "%0 is an immediate %select{function|constructor}5 because "
+  "%select{its body|the%select{| default}7 initializer of %8}6 "
   "%select{evaluates the address of %select{an immediate|a consteval}2 "
   "function %1|contains a call to %select{an immediate|a consteval}2 "
   "%select{function|constructor}4 %1 and that call is not a constant "
   "expression}3">;
 
 def note_invalid_consteval_initializer : Note<
   "in the default initializer of %0">;
 def note_invalid_consteval_initializer_here : Note<

clang/include/clang/Sema/Sema.h

public:
   class SynthesizedFunctionScope {
     Sema &S;
     Sema::ContextRAII SavedContext;
     bool PushedCodeSynthesisContext = false;
 
   public:
     SynthesizedFunctionScope(Sema &S, DeclContext *DC)
         : S(S), SavedContext(S, DC) {
+      auto *FD = dyn_cast<FunctionDecl>(DC);
       S.PushFunctionScope();
       S.PushExpressionEvaluationContext(
-          Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
-      if (auto *FD = dyn_cast<FunctionDecl>(DC)) {
+          (FD && FD->isConsteval())
+              ? ExpressionEvaluationContext::ImmediateFunctionContext
+              : ExpressionEvaluationContext::PotentiallyEvaluated);
+      if (FD) {
         FD->setWillHaveBody(true);
         S.ExprEvalContexts.back().InImmediateFunctionContext =
             FD->isImmediateFunction();
         S.ExprEvalContexts.back().InImmediateEscalatingFunctionContext =
             S.getLangOpts().CPlusPlus20 && FD->isImmediateEscalating();
       } else
         assert(isa<ObjCMethodDecl>(DC));
     }
 
     void addContextNote(SourceLocation UseLoc) {
       assert(!PushedCodeSynthesisContext);
 
       Sema::CodeSynthesisContext Ctx;
       Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;
       Ctx.PointOfInstantiation = UseLoc;
       Ctx.Entity = cast<Decl>(S.CurContext);
       S.pushCodeSynthesisContext(Ctx);
 
       PushedCodeSynthesisContext = true;
     }
 
     ~SynthesizedFunctionScope() {
       if (PushedCodeSynthesisContext)
         S.popCodeSynthesisContext();
-      if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))
+      if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext)) {
         FD->setWillHaveBody(false);
+        S.CheckImmediateEscalatingFunctionDefinition(FD, S.getCurFunction());
+      }
       S.PopExpressionEvaluationContext();
       S.PopFunctionScopeInfo();
     }
   };
 
   /// WeakUndeclaredIdentifiers - Identifiers contained in \#pragma weak before
   /// declared. Rare. May alias another identifier, declared or undeclared.
   ///
public:
   /// it simply returns the passed in expression.
   ExprResult MaybeBindToTemporary(Expr *E);
 
   /// Wrap the expression in a ConstantExpr if it is a potential immediate
   /// invocation.
   ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
 
   bool CheckImmediateEscalatingFunctionDefinition(
-      FunctionDecl *FD, bool HasImmediateEscalatingExpression);
+      FunctionDecl *FD, const sema::FunctionScopeInfo *FSI);
 
   void MarkExpressionAsImmediateEscalating(Expr *E);
 
-  void DiagnoseImmediateEscalatingReason(const clang::FunctionDecl *FD);
+  void DiagnoseImmediateEscalatingReason(FunctionDecl *FD);
 
   bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
                                QualType DeclInitType, MultiExprArg ArgsPtr,
                                SourceLocation Loc,
                                SmallVectorImpl<Expr *> &ConvertedArgs,
                                bool AllowExplicit = false,
                                bool IsListInitialization = false);
 

clang/lib/CodeGen/CGExpr.cpp

RValue CodeGenFunction::EmitCall(QualType CalleeType, const CGCallee &OrigCallee,
   // Get the actual function type. The callee type will always be a pointer to
   // function type or a block pointer type.
   assert(CalleeType->isFunctionPointerType() &&
          "Call must have function pointer type!");
 
   const Decl *TargetDecl =
       OrigCallee.getAbstractInfo().getCalleeDecl().getDecl();
 
+  assert((!isa_and_present<FunctionDecl>(TargetDecl) ||
+          !cast<FunctionDecl>(TargetDecl)->isImmediateFunction()) &&
+         "trying to emit a call to an immediate function");
+
   CalleeType = getContext().getCanonicalType(CalleeType);
 
   auto PointeeType = cast<PointerType>(CalleeType)->getPointeeType();
 
   CGCallee Callee = OrigCallee;
 
   if (SanOpts.has(SanitizerKind::Function) &&
       (!TargetDecl || !isa<FunctionDecl>(TargetDecl)) &&

clang/lib/CodeGen/CodeGenModule.cpp

llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
 
   return llvm::ConstantExpr::getBitCast(F,
                                         Ty->getPointerTo(F->getAddressSpace()));
 }
 
 /// GetAddrOfFunction - Return the address of the given function.  If Ty is
 /// non-null, then this function will use the specified type if it has to
 /// create it (this occurs when we see a definition of the function).
-llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
-                                                 llvm::Type *Ty,
-                                                 bool ForVTable,
-                                                 bool DontDefer,
-                                              ForDefinition_t IsForDefinition) {
-  assert(!cast<FunctionDecl>(GD.getDecl())->isImmediateFunction() &&
-         "an immediate function should never be emitted");
+llvm::Constant *
+CodeGenModule::GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty, bool ForVTable,
   // If there was no specific requested type, just convert it now.
   if (!Ty) {
     const auto *FD = cast<FunctionDecl>(GD.getDecl());
     Ty = getTypes().ConvertType(FD->getType());
   }
 
   // Devirtualized destructor calls may come through here instead of via
   // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
   {
     // Do not call PopExpressionEvaluationContext() if it is a lambda because
     // one is already popped when finishing the lambda in BuildLambdaExpr().
     // This is meant to pop the context added in ActOnStartOfFunctionDef().
     ExitFunctionBodyRAII ExitRAII(*this, isLambdaCallOperator(FD));
     if (FD) {
       FD->setBody(Body);
       FD->setWillHaveBody(false);
-      CheckImmediateEscalatingFunctionDefinition(
-          FD, FSI->FoundImmediateEscalatingExpression);
+      CheckImmediateEscalatingFunctionDefinition(FD, FSI);
 
       if (getLangOpts().CPlusPlus14) {
         if (!FD->isInvalidDecl() && Body && !FD->isDependentContext() &&
             FD->getReturnType()->isUndeducedType()) {
           // For a function with a deduced result type to return void,
           // the result type as written must be 'auto' or 'decltype(auto)',
           // possibly cv-qualified or constrained, but not ref-qualified.
           if (!FD->getReturnType()->getAs<AutoType>()) {

clang/lib/Sema/SemaDeclCXX.cpp

 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include <map>
 #include <optional>
 #include <set>
 
 using namespace clang;
 
 //===----------------------------------------------------------------------===//
 // CheckDefaultArgumentVisitor
if (Kind == Sema::CheckConstexprKind::Diagnose &&
     // Don't return false here: we allow this for compatibility in
     // system headers.
   }
 
   return true;
 }
 
 bool Sema::CheckImmediateEscalatingFunctionDefinition(
-    FunctionDecl *FD, bool HasImmediateEscalatingExpression) {
-  if (!FD->hasBody() || !getLangOpts().CPlusPlus20 ||
-      !FD->isImmediateEscalating())
+    FunctionDecl *FD, const sema::FunctionScopeInfo *FSI) {
+  if (!getLangOpts().CPlusPlus20 || !FD->isImmediateEscalating())
     return true;
   FD->setBodyContainsImmediateEscalatingExpressions(
-      HasImmediateEscalatingExpression);
-  if (HasImmediateEscalatingExpression) {
+      FSI->FoundImmediateEscalatingExpression);
+  if (FSI->FoundImmediateEscalatingExpression) {
     auto it = UndefinedButUsed.find(FD->getCanonicalDecl());
     if (it != UndefinedButUsed.end()) {
       Diag(it->second, diag::err_immediate_function_used_before_definition)
           << it->first;
       Diag(FD->getLocation(), diag::note_defined_here) << FD;
       if (FD->isImmediateFunction() && !FD->isConsteval())
         DiagnoseImmediateEscalatingReason(FD);
       return false;
     }
   }
   return true;
 }
 
-void Sema::DiagnoseImmediateEscalatingReason(const FunctionDecl *FD) {
+void Sema::DiagnoseImmediateEscalatingReason(FunctionDecl *FD) {
   assert(FD->isImmediateEscalating() && !FD->isConsteval() &&
          "expected an immediate function");
   assert(FD->hasBody() && "expected the function to have a body");
   struct ImmediateEscalatingExpressionsVisitor
       : public RecursiveASTVisitor<ImmediateEscalatingExpressionsVisitor> {
+
     using Base = RecursiveASTVisitor<ImmediateEscalatingExpressionsVisitor>;
     Sema &SemaRef;
-    const FunctionDecl *FD;
-    ImmediateEscalatingExpressionsVisitor(Sema &SemaRef, const FunctionDecl *FD)
-        : SemaRef(SemaRef), FD(FD) {}
+
+    const FunctionDecl *ImmediateFn;
+    bool ImmediateFnIsConstructor;
+    CXXConstructorDecl *CurrentConstructor = nullptr;
+    CXXCtorInitializer *CurrentInit = nullptr;
+
+    ImmediateEscalatingExpressionsVisitor(Sema &SemaRef, FunctionDecl *FD)
+        : SemaRef(SemaRef), ImmediateFn(FD),
+          ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {}
 
     bool shouldVisitImplicitCode() const { return true; }
     bool shouldVisitLambdaBody() const { return false; }
 
+    void Diag(const Expr *E, const FunctionDecl *Fn, bool IsCall) {
+      SourceLocation Loc = E->getBeginLoc();
+      SourceRange Range = E->getSourceRange();
+      if (CurrentConstructor && CurrentInit) {
+        Loc = CurrentConstructor->getLocation();
+        Range = CurrentInit->isWritten() ? CurrentInit->getSourceRange()
+                                         : SourceRange();
+      }
+      SemaRef.Diag(Loc, diag::note_immediate_function_reason)
+          << ImmediateFn << Fn << Fn->isConsteval() << IsCall
+          << isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor
+          << (CurrentInit != nullptr)
+          << (CurrentInit && !CurrentInit->isWritten())
+          << (CurrentInit ? CurrentInit->getAnyMember() : nullptr) << Range;
+    }
     bool TraverseCallExpr(CallExpr *E) {
       if (const auto *DR =
               dyn_cast<DeclRefExpr>(E->getCallee()->IgnoreImplicit());
           DR && DR->isImmediateEscalating()) {
-        SemaRef.Diag(E->getBeginLoc(), diag::note_immediate_function_reason)
-            << FD << E->getDirectCallee() << E->getDirectCallee()->isConsteval()
-            << /*Call*/ 1 << /*Function*/ 0 << E->getSourceRange();
-      }
-      for (auto A : E->arguments()) {
-        getDerived().TraverseStmt(A);
+        Diag(E, E->getDirectCallee(), /*IsCall=*/true);
+        return false;
       }
+
+      for (Expr *A : E->arguments())
+        if (!getDerived().TraverseStmt(A))
+          return false;
+
       return true;
     }
+
     bool VisitDeclRefExpr(DeclRefExpr *E) {
       if (const auto *ReferencedFn = dyn_cast<FunctionDecl>(E->getDecl());
           ReferencedFn && E->isImmediateEscalating()) {
-        SemaRef.Diag(E->getBeginLoc(), diag::note_immediate_function_reason)
-            << FD << ReferencedFn << ReferencedFn->isConsteval()
-            << /*Address*/ 0 << /*Function*/ 0 << E->getSourceRange();
+        Diag(E, ReferencedFn, /*IsCall=*/false);
+        return false;
       }
+
       return true;
     }
+
     bool VisitCXXConstructExpr(CXXConstructExpr *E) {
       CXXConstructorDecl *D = E->getConstructor();
       if (E->isImmediateEscalating()) {
-        SemaRef.Diag(E->getBeginLoc(), diag::note_immediate_function_reason)
-            << FD << D << D->isConsteval() << /*Call*/ 1 << /*Constructor*/ 1
-            << E->getSourceRange();
+        Diag(E, D, /*IsCall=*/true);
+        return false;
       }
       return true;
     }
 
-    // These nodes can never contain an immediate escalating expression,
-    // we can skip them to avoid unecessary work.
-    bool TraverseDecl(Decl *D) {
-      if (isa<FunctionDecl, RecordDecl>(D))
-        return true;
-      return Base::TraverseDecl(D);
+    bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
+      llvm::SaveAndRestore RAII(CurrentInit, Init);
+      return Base::TraverseConstructorInitializer(Init);
+    }
+
+    bool TraverseCXXConstructorDecl(CXXConstructorDecl *Ctr) {
+      llvm::SaveAndRestore RAII(CurrentConstructor, Ctr);
+      return Base::TraverseCXXConstructorDecl(Ctr);
     }
+
     bool TraverseType(QualType T) { return true; }
     bool VisitBlockExpr(BlockExpr *T) { return true; }
 
   } Visitor(*this, FD);
-  Visitor.TraverseStmt(FD->getBody());
+  Visitor.TraverseDecl(FD);
 }
 
 /// Get the class that is directly named by the current context. This is the
 /// class for which an unqualified-id in this scope could name a constructor
 /// or destructor.
 ///
 /// If the scope specifier denotes a class, this will be that class.
 /// If the scope specifier is empty, this will be the class whose

clang/lib/Sema/SemaExpr.cpp

bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD,
   return false;
 }
 
 struct ImmediateCallVisitor : public RecursiveASTVisitor<ImmediateCallVisitor> {
   const ASTContext &Context;
   ImmediateCallVisitor(const ASTContext &Ctx) : Context(Ctx) {}
 
   bool HasImmediateCalls = false;
-  bool IsImmediateInvocation = false;
-
   bool shouldVisitImplicitCode() const { return true; }
 
   bool VisitCallExpr(CallExpr *E) {
-    if (const FunctionDecl *FD = E->getDirectCallee()) {
+    if (const FunctionDecl *FD = E->getDirectCallee())
       HasImmediateCalls |= FD->isImmediateFunction();
-      if (FD->isConsteval() && !E->isCXX11ConstantExpr(Context))
-        IsImmediateInvocation = true;
-    }
-
     return RecursiveASTVisitor<ImmediateCallVisitor>::VisitStmt(E);
   }
 
   // SourceLocExpr are not immediate invocations
   // but CXXDefaultInitExpr/CXXDefaultArgExpr containing a SourceLocExpr
   // need to be rebuilt so that they refer to the correct SourceLocation and
   // DeclContext.
   bool VisitSourceLocExpr(SourceLocExpr *E) {

 
 ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   assert(Field->hasInClassInitializer());
 
   // If we might have already tried and failed to instantiate, don't try again.
   if (Field->isInvalidDecl())
     return ExprError();
 
+  CXXThisScopeRAII This(*this, Field->getParent(), Qualifiers());
+
   auto *ParentRD = cast<CXXRecordDecl>(Field->getParent());
 
   std::optional<ExpressionEvaluationContextRecord::InitializationContext>
       InitializationContext =
           OutermostDeclarationWithDelayedImmediateInvocations();
   if (!InitializationContext.has_value())
     InitializationContext.emplace(Loc, Field, CurContext);
 
ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   // An immediate invocation that is not evaluated where it appears is
   // evaluated and checked for whether it is a constant expression at the
   // point where the enclosing initializer is used in a [...] a constructor
   // definition, or an aggregate initialization.
   ImmediateCallVisitor V(getASTContext());
   if (!NestedDefaultChecking)
     V.TraverseDecl(Field);
   if (V.HasImmediateCalls) {
-    // C++23 [expr.const]/p15
-    // An aggregate initialization is an immediate invocation
-    // if it evaluates a default member initializer that has a subexpression
-    // that is an immediate-escalating expression.
-    ExprEvalContexts.back().InImmediateFunctionContext |=
-        V.IsImmediateInvocation;
-
     ExprEvalContexts.back().DelayedDefaultInitializationContext = {Loc, Field,
                                                                    CurContext};
     ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
         NestedDefaultChecking;
 
     EnsureImmediateInvocationInDefaultArgs Immediate(*this);
     ExprResult Res;
     runWithSufficientStackSpace(Loc, [&] {
if (Rec.ImmediateInvocationCandidates.size() > 1 ||
     } Visitor(Rec.ReferenceToConsteval);
     Visitor.TraverseStmt(
         Rec.ImmediateInvocationCandidates.front().getPointer()->getSubExpr());
   }
   for (auto CE : Rec.ImmediateInvocationCandidates)
     if (!CE.getInt())
       EvaluateAndDiagnoseImmediateInvocation(SemaRef, CE);
   for (auto *DR : Rec.ReferenceToConsteval) {
-    const auto *FD = cast<FunctionDecl>(DR->getDecl());
+    // If the expression is immediate escalating, it is not an error;
+    // The outer context itself becomes immediate and further errors,
+    // if any, will be handled by DiagnoseImmediateEscalatingReason.
+    if (DR->isImmediateEscalating())
+      continue;
+    auto *FD = cast<FunctionDecl>(DR->getDecl());
     const NamedDecl *ND = FD;
     if (const auto *MD = dyn_cast<CXXMethodDecl>(ND);
         MD && (MD->isLambdaStaticInvoker() || isLambdaCallOperator(MD)))
       ND = MD->getParent();
 
     // C++23 [expr.const]/p16
     // An expression or conversion is immediate-escalating if it is not
     // initially in an immediate function context and it is [...] a
     // potentially-evaluated id-expression that denotes an immediate function
     // that is not a subexpression of an immediate invocation.
     bool ImmediateEscalating = false;
     bool IsPotentiallyEvaluated =
         Rec.Context ==
             Sema::ExpressionEvaluationContext::PotentiallyEvaluated ||
         Rec.Context ==
             Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed;
     if (SemaRef.inTemplateInstantiation() && IsPotentiallyEvaluated)
       ImmediateEscalating = Rec.InImmediateEscalatingFunctionContext;
 
     if (!Rec.InImmediateEscalatingFunctionContext ||
         (SemaRef.inTemplateInstantiation() && !ImmediateEscalating)) {
       SemaRef.Diag(DR->getBeginLoc(), diag::err_invalid_consteval_take_address)
           << ND << isa<CXXRecordDecl>(ND) << FD->isConsteval();
       SemaRef.Diag(ND->getLocation(), diag::note_declared_at);
+      if (auto Context =
+              SemaRef.InnermostDeclarationWithDelayedImmediateInvocations()) {
+        SemaRef.Diag(Context->Loc, diag::note_invalid_consteval_initializer)
+            << Context->Decl;
+        SemaRef.Diag(Context->Decl->getBeginLoc(), diag::note_declared_at);
+      }
       if (FD->isImmediateEscalating() && !FD->isConsteval())
         SemaRef.DiagnoseImmediateEscalatingReason(FD);
+
     } else {
       SemaRef.MarkExpressionAsImmediateEscalating(DR);
     }
   }
 }
 
 void Sema::PopExpressionEvaluationContext() {
   ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
runWithSufficientStackSpace(Loc, [&] {
       }
     });
   }
 
   // If a constructor was defined in the context of a default parameter
   // or of another default member initializer (ie a PotentiallyEvaluatedIfUsed
   // context), its initializers may not be referenced yet.
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Func)) {
+    EnterExpressionEvaluationContext EvalContext(
+        *this,
+        Constructor->isImmediateFunction()
+            ? ExpressionEvaluationContext::ImmediateFunctionContext
+            : ExpressionEvaluationContext::PotentiallyEvaluated,
+        Constructor);
     for (CXXCtorInitializer *Init : Constructor->inits()) {
       if (Init->isInClassMemberInitializer())
         runWithSufficientStackSpace(Init->getSourceLocation(), [&]() {
           MarkDeclarationsReferencedInExpr(Init->getInit());
         });
     }
   }
 

clang/test/CodeGenCXX/cxx2c-consteval-propagate.cpp

+// RUN: %clang_cc1 -emit-llvm %s -std=c++20 -triple x86_64-unknown-linux-gnu -o - | FileCheck %s
+
+namespace GH63742 {
+
+void side_effect();
+consteval int f(int x) {
+    if (!__builtin_is_constant_evaluated()) side_effect();
+    return x;
+}
+struct SS {
+    int x = f(42);
+    SS();
+};
+SS::SS(){}
+
+}
+
+// CHECK-LABEL: @_ZN7GH637422SSC2Ev
+// CHECK-NOT:   call
+// CHECK:       store i32 42, ptr {{.*}}
+// CHECK:       ret void

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

struct UnusedInitWithLambda {
     }();
     // UnusedInitWithLambda is never constructed, so the initializer
     // of b and undefined() are never evaluated.
     int b = [](int no_error = undefined()) {
         return no_error;
     }();
 };
 
-consteval int ub(int n) { // expected-note {{declared here}}
+consteval int ub(int n) {
     return 0/n;
 }
 
-struct InitWithLambda {
-    int b = [](int error = undefined()) { // expected-error {{cannot take address of consteval function 'undefined' outside of an immediate invocation}}
+struct InitWithLambda { // expected-note {{'InitWithLambda' is an immediate constructor because the default initializer of 'b' contains a call to a consteval function 'undefined' and that call is not a constant expression}}
+    int b = [](int error = undefined()) {  // expected-note {{undefined function 'undefined' cannot be used in a constant expression}}
         return error;
     }();
-    int c = [](int error = sizeof(undefined()) + ub(0)) { // expected-error {{cannot take address of consteval function 'ub' outside of an immediate invocation}}
+    int c = [](int error = sizeof(undefined()) + ub(0)) {
 
         return error;
     }();
 } i;
+// expected-error@-1 {{call to immediate function 'InitWithLambda::InitWithLambda' is not a constant expression}} \
+   expected-note@-1 {{in call to 'InitWithLambda()'}}
 
 namespace ShouldNotCrash {
     template<typename T>
     struct F {
         template<typename U>
         F(const U&) {}
     };
     struct A {

clang/test/SemaCXX/cxx2b-consteval-propagate.cpp

-// RUN: %clang_cc1 -std=c++2a -emit-llvm-only -Wno-unused-value %s -verify
-// RUN: %clang_cc1 -std=c++2b -emit-llvm-only -Wno-unused-value %s -verify
+// RUN: %clang_cc1 -std=c++2a -Wno-unused-value %s -verify
+// RUN: %clang_cc1 -std=c++2b -Wno-unused-value %s -verify
 
 consteval int id(int i) { return i; }
 constexpr char id(char c) { return c; }
 
 template <typename T>
 constexpr int f(T t) { // expected-note {{declared here}}
     return t + id(t);  // expected-note 2{{'f<int>' is an immediate function because its body contains a call to a consteval function 'id' and that call is not a constant expression}}
 }

 consteval bool is_even(int i) { return i % 2 == 0; }
 
 static_assert(is_not(5, is_even));
 
 int x = 0; // expected-note {{declared here}}
 
 template <typename T>
 constexpr T h(T t = id(x)) { // expected-note {{read of non-const variable 'x' is not allowed in a constant expression}} \
-                             // expected-note 2{{'hh<int>' is an immediate function because its body contains a call to a consteval function 'id' and that call is not a constant expression}}
+                             // expected-note {{'hh<int>' is an immediate function because its body contains a call to a consteval function 'id' and that call is not a constant expression}}
     return t;
 }
 
 template <typename T>
 constexpr T hh() {           // hh<int> is an immediate function
     [[maybe_unused]] auto x = h<T>();
     return h<T>();
 }

 };
 constexpr int g(auto t) {
     S s(t); // expected-note {{'g<int>' is an immediate function because its body contains a call to a consteval constructor 'S' and that call is not a constant expression}}
     return 0;
 }
 int i = g(x); // expected-error {{call to immediate function 'ConstevalConstructor::g<int>' is not a constant expression}} \
               // expected-note {{read of non-const variable 'x' is not allowed in a constant expression}}
 }
+
+
+
+namespace Aggregate {
+consteval int f(int); // expected-note {{declared here}}
+struct S {
+  int x = f(42); // expected-note {{undefined function 'f' cannot be used in a constant expression}} \
+                 // expected-note {{'immediate<int>' is an immediate function because its body contains a call to a consteval function 'f' and that call is not a constant expression}}
+};
+
+constexpr S immediate(auto) {
+    return S{};
+}
+
+void test_runtime() {
+    (void)immediate(0); // expected-error {{call to immediate function 'Aggregate::immediate<int>' is not a constant expression}} \
+                        // expected-note {{in call to 'immediate(0)'}}
+}
+consteval int f(int i) {
+    return i;
+}
+consteval void test() {
+    constexpr S s = immediate(0);
+    static_assert(s.x == 42);
+}
+}
+
+
+
+namespace GH63742 {
+void side_effect(); // expected-note  {{declared here}}
+consteval int f(int x) {
+    if (!x) side_effect(); // expected-note {{non-constexpr function 'side_effect' cannot be used in a constant expression}}
+    return x;
+}
+struct SS {
+  int y = f(1); // Ok
+  int x = f(0); // expected-error {{call to consteval function 'GH63742::f' is not a constant expression}} \
+                // expected-note  {{declared here}} \
+                // expected-note  {{in call to 'f(0)'}}
+  SS();
+};
+SS::SS(){} // expected-note {{in the default initializer of 'x'}}
+
+consteval int f2(int x) {
+    if (!__builtin_is_constant_evaluated()) side_effect();
+    return x;
+}
+struct S2 {
+    int x = f2(0);
+    constexpr S2();
+};
+
+constexpr S2::S2(){}
+S2 s = {};
+constinit S2 s2 = {};
+
+struct S3 {
+    int x = f2(0);
+    S3();
+};
+S3::S3(){}
+
+}
+
+namespace Defaulted {
+consteval int f(int x);
+struct SS {
+  int x = f(0);
+  SS() = default;
+};
+}
+
+namespace DefaultedUse{
+consteval int f(int x);  // expected-note {{declared here}}
+struct SS {
+  int a = sizeof(f(0)); // Ok
+  int x = f(0); // expected-note {{undefined function 'f' cannot be used in a constant expression}}
+
+  SS() = default; // expected-note {{'SS' is an immediate constructor because the default initializer of 'x' contains a call to a consteval function 'f' and that call is not a constant expression}}
+};
+
+void test() {
+    [[maybe_unused]] SS s; // expected-error {{call to immediate function 'DefaultedUse::SS::SS' is not a constant expression}} \
+                           //  expected-note {{in call to 'SS()'}}
+}
+}
+
+namespace UserDefinedConstructors {
+consteval int f(int x) {
+    return x;
+}
+extern int NonConst; // expected-note 2{{declared here}}
+
+struct ConstevalCtr {
+    int y;
+    int x = f(y);
+    consteval ConstevalCtr(int yy)
+    : y(f(yy)) {}
+};
+
+ConstevalCtr c1(1);
+ConstevalCtr c2(NonConst);
+// expected-error@-1 {{call to consteval function 'UserDefinedConstructors::ConstevalCtr::ConstevalCtr' is not a constant expression}} \
+// expected-note@-1 {{read of non-const variable 'NonConst' is not allowed in a constant expression}}
+
+struct ImmediateEscalating {
+    int y;
+    int x = f(y);
+    template<typename T>
+    constexpr ImmediateEscalating(T yy) // expected-note {{ImmediateEscalating<int>' is an immediate constructor because the initializer of 'y' contains a call to a consteval function 'f' and that call is not a constant expression}}
+    : y(f(yy)) {}
+};
+
+ImmediateEscalating c3(1);
+ImmediateEscalating c4(NonConst);
+// expected-error@-1 {{call to immediate function 'UserDefinedConstructors::ImmediateEscalating::ImmediateEscalating<int>' is not a constant expression}} \
+// expected-note@-1 {{read of non-const variable 'NonConst' is not allowed in a constant expression}}
+
+
+struct NonEscalating {
+    int y;
+    int x = f(this->y); // expected-error {{call to consteval function 'UserDefinedConstructors::f' is not a constant expression}} \
+                        // expected-note  {{declared here}} \
+                        // expected-note  {{use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function}}
+    constexpr NonEscalating(int yy) : y(yy) {} // expected-note {{in the default initializer of 'x'}}
+};
+NonEscalating s = {1};
+
+}
+
+namespace AggregateInit {
+
+consteval int f(int x) {
+    return x;
+}
+
+struct S {
+    int i;
+    int j = f(i);
+};
+
+constexpr S  test(auto) {
+    return {};
+}
+
+S s = test(0);
+
+}
+
+namespace GlobalAggregateInit {
+
+consteval int f(int x) {
+    return x;
+}
+
+struct S {
+    int i;
+    int j = f(i); // expected-error {{call to consteval function 'GlobalAggregateInit::f' is not a constant expression}} \
+                  // expected-note {{implicit use of 'this' pointer is only allowed within the evaluation of a call to a 'constexpr' member function}} \
+                  // expected-note {{declared here}}
+};
+
+S s(0); // expected-note {{in the default initializer of 'j'}}
+
+}