PotentiallyEvaluatedContext in a ImmediateFunctionContext.

[usaxena95]

Summary

Body of consteval should be in an ImmediateFunctionContext instead of ConstantEvaluated.
PotentiallyEvaluated expressions in Immediate functions are in a ImmediateFunctionContext as well.

Fixes https://github.com/llvm/llvm-project/issues/51182
Original divergence: https://godbolt.org/z/vadGT5j6f

[shafik]

This looks good to me but I want another set of eyes on this.

clang/test/SemaCXX/cxx2a-consteval.cpp

942

Please add a newline

[shafik]

CC @cor3ntin

[cor3ntin]

Yes, this looks good to me too. Thanks for working on this.
Can you modify ReleaseNotes.rst to mention the fixed issue?

clang/include/clang/Sema/Sema.h

1355

clang/lib/Sema/SemaDecl.cpp

14774

[aaron.ballman]

Adding a few more reviewers just in case, but this is generally looking good. Please also add a release note for the fix!

clang/include/clang/Sema/Sema.h

1355

1357–1359

clang/lib/Sema/SemaDecl.cpp

14774

[usaxena95]

Thanks for the quick review.
Addressed comments.

[usaxena95]

Added release notes.

[aaron.ballman]

LGTM!

clang/include/clang/Sema/Sema.h

struct ExpressionEvaluationContextRecord {
     bool isConstantEvaluated() const {
       return Context == ExpressionEvaluationContext::ConstantEvaluated ||
              Context == ExpressionEvaluationContext::ImmediateFunctionContext;
     }
 
     bool isImmediateFunctionContext() const {
       return Context == ExpressionEvaluationContext::ImmediateFunctionContext ||
              (Context == ExpressionEvaluationContext::DiscardedStatement &&
+              InImmediateFunctionContext) ||
+             // [expr.const#def:immediate_function_context]
+             // An expression or conversion is in an immediate function
+             // context if it is potentially evaluated and either: its
+             // innermost enclosing non-block scope is a function parameter
+             // scope of an immediate function.
+             (Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
               InImmediateFunctionContext);
     }
 
     bool isDiscardedStatementContext() const {
       return Context == ExpressionEvaluationContext::DiscardedStatement ||
              (Context ==
                   ExpressionEvaluationContext::ImmediateFunctionContext &&
               InDiscardedStatement);

clang/lib/Sema/SemaDecl.cpp

Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D,
   if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
     FD = FunTmpl->getTemplatedDecl();
   else
     FD = cast<FunctionDecl>(D);
 
   // Do not push if it is a lambda because one is already pushed when building
   // the lambda in ActOnStartOfLambdaDefinition().
   if (!isLambdaCallOperator(FD))
+    // [expr.const#def:immediate_function_context]
+    // An expression or conversion is in an immediate function context if it is
+    // potentially evaluated and either: its innermost enclosing non-block scope
+    // is a function parameter scope of an immediate function.
     PushExpressionEvaluationContext(
-        FD->isConsteval() ? ExpressionEvaluationContext::ConstantEvaluated
+        FD->isConsteval() ? ExpressionEvaluationContext::ImmediateFunctionContext
                           : ExprEvalContexts.back().Context);
 
   // Check for defining attributes before the check for redefinition.
   if (const auto *Attr = FD->getAttr<AliasAttr>()) {
     Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;
     FD->dropAttr<AliasAttr>();
     FD->setInvalidDecl();
   }

clang/lib/Sema/SemaExpr.cpp

void Sema::MarkDeclRefReferenced(DeclRefExpr *E, const Expr *Base) {
   bool OdrUse = true;
   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(E->getDecl()))
     if (Method->isVirtual() &&
         !Method->getDevirtualizedMethod(Base, getLangOpts().AppleKext))
       OdrUse = false;
 
   if (auto *FD = dyn_cast<FunctionDecl>(E->getDecl()))
     if (!isUnevaluatedContext() && !isConstantEvaluated() &&
-        FD->isConsteval() && !RebuildingImmediateInvocation &&
-        !FD->isDependentContext())
+        !isImmediateFunctionContext() && FD->isConsteval() &&
+        !RebuildingImmediateInvocation && !FD->isDependentContext())
       ExprEvalContexts.back().ReferenceToConsteval.insert(E);
   MarkExprReferenced(*this, E->getLocation(), E->getDecl(), E, OdrUse,
                      RefsMinusAssignments);
 }
 
 /// Perform reference-marking and odr-use handling for a MemberExpr.
 void Sema::MarkMemberReferenced(MemberExpr *E) {
   // C++11 [basic.def.odr]p2:

clang/test/SemaCXX/cxx2a-consteval.cpp

 // expected-error@-1 {{integer value -1 is outside the valid range of values [0, 1] for this enumeration type}}
   return (int)eParam;
 }
 
 int test() {
   return testDefaultArgForParam() + testDefaultArgForParam((E)1);
 }
 }
+
+namespace GH51182 {
+// Nested consteval function.
+consteval int f(int v) {
+  return v;
+}
+
+template <typename T>
+consteval int g(T a) {
+  // An immediate function context.
+  int n = f(a);
+  return n;
+}
+static_assert(g(100) == 100);
+// --------------------------------------
+template <typename T>
+consteval T max(const T& a, const T& b) {
+    return (a > b) ? a : b;
+}
+template <typename T>
+consteval T mid(const T& a, const T& b, const T& c) {
+    T m = max(max(a, b), c);
+    if (m == a)
+        return max(b, c);
+    if (m == b)
+        return max(a, c);
+    return max(a, b);
+}
+static_assert(max(1,2)==2);
+static_assert(mid(1,2,3)==2);
+} // namespace GH51182
 No newline at end of file