[clang] Treat function parameter scope as an immediate function context

[Fznamznon]

Summary

This results in expressions that appear in default function argument not
being checked for being actual constant expressions.
This aligns clang's behavior with the standard and fixes one of the
examples from https://wg21.link/P1073R3.

[cor3ntin]

I think this make sense.
Maybe we should add a comment quoting [expr.const] p15.1 in both places though.

[shafik]

This LGTM, I agree w/ @cor3ntin about quoting [expr.cont] to document this choice.

[Fznamznon]

Rebase and add quoting [expr.const] p15.1

[cor3ntin]

Thanks, LGTM

clang/lib/Sema/SemaExpr.cpp

if (auto *InitWithCleanup = dyn_cast<ExprWithCleanups>(Init)) {
     // any explicit objects.
     Cleanup.setExprNeedsCleanups(InitWithCleanup->cleanupsHaveSideEffects());
     // Append all the objects to the cleanup list.  Right now, this
     // should always be a no-op, because blocks in default argument
     // expressions should never be able to capture anything.
     assert(!InitWithCleanup->getNumObjects() &&
            "default argument expression has capturing blocks?");
   }
+  // C++ [expr.const]p15.1:
+  //   An expression or conversion is in an immediate function context if it is
+  //   potentially evaluated and [...] its innermost enclosing non-block scope
+  //   is a function parameter scope of an immediate function.
   EnterExpressionEvaluationContext EvalContext(
-      *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
+      *this,
+      FD->isConsteval() ? ExpressionEvaluationContext::ImmediateFunctionContext
+                        : ExpressionEvaluationContext::PotentiallyEvaluated,
+      Param);
   ExprEvalContexts.back().IsCurrentlyCheckingDefaultArgumentOrInitializer =
       SkipImmediateInvocations;
   MarkDeclarationsReferencedInExpr(Init, /*SkipLocalVariables*/ true);
   return false;
 }
 
 struct ImmediateCallVisitor : public RecursiveASTVisitor<ImmediateCallVisitor> {
   bool HasImmediateCalls = false;
std::optional<ExpressionEvaluationContextRecord::InitializationContext>
           OutermostDeclarationWithDelayedImmediateInvocations();
   if (!InitializationContext.has_value())
     InitializationContext.emplace(CallLoc, Param, CurContext);
 
   if (!Init && !Param->hasUnparsedDefaultArg()) {
     // Mark that we are replacing a default argument first.
     // If we are instantiating a template we won't have to
     // retransform immediate calls.
+    // C++ [expr.const]p15.1:
+    //   An expression or conversion is in an immediate function context if it
+    //   is potentially evaluated and [...] its innermost enclosing non-block
+    //   scope is a function parameter scope of an immediate function.
     EnterExpressionEvaluationContext EvalContext(
-        *this, ExpressionEvaluationContext::PotentiallyEvaluated, Param);
+        *this,
+        FD->isConsteval()
+            ? ExpressionEvaluationContext::ImmediateFunctionContext
+            : ExpressionEvaluationContext::PotentiallyEvaluated,
+        Param);
 
     if (Param->hasUninstantiatedDefaultArg()) {
       if (InstantiateDefaultArgument(CallLoc, FD, Param))
         return ExprError();
     }
     // CWG2631
     // An immediate invocation that is not evaluated where it appears is
     // evaluated and checked for whether it is a constant expression at the

clang/test/CXX/expr/expr.const/p6-2a.cpp

struct Temporary {
   int &&temp;
   constexpr ~Temporary() {
     int n = temp; // expected-note {{outside the expression that created the temporary}}
   }
 };
 constexpr Temporary t = {3}; // expected-error {{must have constant destruction}} expected-note {{created here}} expected-note {{in call}}
 
 namespace P1073R3 {
-consteval int f() { return 42; } // expected-note 3 {{declared here}}
+consteval int f() { return 42; } // expected-note 2 {{declared here}}
 consteval auto g() { return f; }
-// FIXME: there should be no diagnostics associated with either h() or r.
-consteval int h(int (*p)() = g()) { return p(); } // expected-error {{call to consteval function 'P1073R3::g' is not a constant expression}} \
-                                                     expected-note {{declared here}} \
-                                                     expected-note {{pointer to a consteval declaration is not a constant expression}}
-constexpr int r = h();   // expected-note {{in the default initalizer of 'p'}}
+consteval int h(int (*p)() = g()) { return p(); }
+constexpr int r = h();
 constexpr auto e = g();  // expected-error {{call to consteval function 'P1073R3::g' is not a constant expression}} \
                             expected-error {{constexpr variable 'e' must be initialized by a constant expression}} \
                             expected-note 2 {{pointer to a consteval declaration is not a constant expression}}
+static_assert(r == 42);
 } // namespace P1073R3