[clang] fix consteval call in default arguments

[Tyker]

Summary

I spotted some issues with consteval call in some contexts.

consteval int f1() { return 0; }
consteval auto g() { return f1; }

consteval int h(int (*p)() = g()) { return p(); } // currently generate an error
constexpr auto e = g(); // currently generate 2 errors instead of 1.
auto l2 = [](int (*p)() = g()) consteval { return p(); }; // currently generate an error

this patch fixes these issues

[Tyker]

ping

[Tyker]

rebased and add more fixes

[keryell]

clang/lib/Sema/SemaExpr.cpp

15443

[rsmith]

clang/include/clang/Parse/Parser.h

2780

clang/include/clang/Sema/Sema.h

1071

1073

4483

Can you model this as an ExpressionEvaluationContextRecord::ExpressionKind instead of a new parameter?

clang/lib/Sema/Sema.cpp

1026 ↗

(On Diff #298344)

What do we need this for? If I'm understanding the patch correctly, I think the only way we should propagate immediate invocations upwards should be from the ExpressionEvaluationContext of a lambda default argument into the ExpressionEvaluationContext of the lambda itself, so it should never reach the top level.

clang/lib/Sema/SemaDeclCXX.cpp

16719–16722

This needs a comment explaining what's going on: why are constexpr / constinit variables special here, but (for example) a variable of type const int is not?

Actually, I think this change might not be correct. Consider the following:

consteval void check(bool b) { if (!b) throw; }
constinit int x = true ? 1 : (check(false), 2);

This code is ill-formed: the immediate invocation of check(false) is not a constant expression. But I think with this code change, we won't require check(false) to be a constant expression, instead deferring to checking whether the initializer of x as a whole is a constant expression (which it is!). So we'll accept invalid code.

16736

Do we need to restore the old value here, rather than resetting to false? In a case like:

consteval int g() { return 0; }
constexpr int a = ({ constexpr int b = 0; g(); });

it looks like we'd lose the 'override' flag at the end of the definition of b.

Generally I find the idea of using a global override flag like this to be dubious: there are a lot of ways in which we switch context during Sema, and we'd need to make sure we switch out this context at those times too. If we can avoid using a global state flag for this (for example by carrying this on the ExpressionEvaluationContextRecord, that'd be a lot less worrying.

clang/lib/Sema/SemaExpr.cpp

15204–15206

I'm a little uncomfortable about assuming that the innermost ExpressionEvaluationContext surrounding a lambda parameter is always a context for the lambda expression itself -- that's making a lot of assumptions about what contexts might be added in the future.

Instead of propagating this information from the lambda parameter context to the (presumed) lambda context when we pop an expression evaluation context for a lambda parameter, could we pull out the LambdaScopeInfo for the current lambda (getCurLambda()) and store the information there, to be either diagnosed or dropped when we reach ActOnStartOfLambdaDefinition?

clang/lib/Sema/SemaLambda.cpp

893–894

We've already parsed the default arguments at this point; it would seem simpler to directly clear out the immediate invocation state from the ExpressionEvaluationContextRecord rather than asking it to do that at the end of the scope. This would also remove the need for the IIESA_Drop mode entirely; if you also change the IsLambdaParamScope flag into an ExpressionKind on the context record, that would remove the need for the IIEndScopeAction field, given the information you need at the end of a scope is whether the ExpressionKind is that of a lambda parameter or not.

[Tyker]

addressed comments.

clang/lib/Sema/Sema.cpp

1026 ↗

(On Diff #298344)

This is fixing a separate bug that consteval call in to top-level ExprEvalContext are not handled.
like this:

struct S {
  consteval S(bool b) {if (b) throw;}
};
S s2(true);

this emits no error.
because the immediate invocation are added to global scope and the global scope is never poped via PopExpressionEvaluationContext.

clang/lib/Sema/SemaDeclCXX.cpp

16719–16722

this fixes an issue where we would generate 2 error when we couldn't evaluate a consteval call inside the initialization of a constexpr/constinit
variable.

consteval void check(bool b) { if (!b) throw; }
constinit int x = (check(false), 2);

one of those error is "call to consteval function 'check' is not a constant expression"
the second is "variable does not have a constant initializer"

i fixed it by marking the expression as failed when the consteval call fails.

16736

i changed approach and this isn't needed anymore.

[rsmith]

clang/lib/Sema/Sema.cpp

1026 ↗

(On Diff #298344)

In this case, what's supposed to happen is that we create an ExpressionEvaluationContext for the initializer of s2. See Sema::ActOnCXXEnterDeclInitializer / Sema::ActOnCXXExitDeclInitializer. I guess that's not working somehow?

Ah, the problem is that we leave the context too early in Parser::ParseDeclarationAfterDeclaratorAndAttributes. We call InitScope.pop() before we add the initializer to the declaration, which is where we actually finish building the initialization full-expression -- that seems wrong in general. (We're also missing an InitializerScopeRAII object around the call to ActOnUninitializedDecl in the case where there is no initializer -- we need an ExpressionEvaluationContext for the default-initialization in that case too.)

clang/lib/Sema/SemaExpr.cpp

15333

Changing the dependence flags on an expression isn't safe to do this late: the Error dependence bit should be propagated to all transitive enclosing AST nodes when they're created, which has already happened at this point. If we need a way to represent an expression that's supposed to be a constant expression but isn't constant, perhaps adding a separate flag to ConstantExpr would be reasonable.

clang/lib/Sema/SemaLambda.cpp

895–899

Thanks! I think this can be cleaned up a little bit further:

• Move the handling of lambda parameter scopes from HandleImmediateInvocations to PopExpressionEvaluationContext
• Change HandleImmediateInvocations to take the ReferenceToConsteval and ImmediateInvocationCandidates data instead of an ExpressionEvaluationContextRecord
• Maybe consider wrapping ReferenceToConsteval and ImmediateInvocationCandidates in a struct to make it a bit easier to pass them around as a set.

[aaron.ballman]

@Tyker -- are you planning to pick this review back up again sometime in the near future? If not, do you care if the review gets commandeered?

[Tyker]

In D74130#3073271, @aaron.ballman wrote:

@Tyker -- are you planning to pick this review back up again sometime in the near future? If not, do you care if the review gets commandeered?

here is an update that i think is close to committable. if it is not i am fine if it gets commandeered.

Changes

• rebased
• fix the default parameter situation for functions and lambdas.
• fix the top level variables not being properly checked.

the double errors are not fixed on code like:

consteval int f1() { return 0; }
consteval auto g() { return f1; }

constexpr auto e = g();
constexpr auto e1 = f1;

[aaron.ballman]

In D74130#3079630, @Tyker wrote:

In D74130#3073271, @aaron.ballman wrote:

@Tyker -- are you planning to pick this review back up again sometime in the near future? If not, do you care if the review gets commandeered?

here is an update that i think is close to committable. if it is not i am fine if it gets commandeered.

Changes

• rebased
• fix the default parameter situation for functions and lambdas.
• fix the top level variables not being properly checked.

the double errors are not fixed on code like:

consteval int f1() { return 0; }
consteval auto g() { return f1; }

constexpr auto e = g();
constexpr auto e1 = f1;

Thank you for the update and letting me know you're fine if this is commandeered.

FWIW, I am not seeing double errors on that code. Here's the output I get with this patch applied locally:

F:\source\llvm-project>cat "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp"
consteval int f1() { return 0; }
consteval auto g() { return f1; }

constexpr auto e = g();
constexpr auto e1 = f1;

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only -std=c++2b "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:20: error: call to consteval function 'g' is not a
      constant expression
constexpr auto e = g();
                   ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:20: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:16: error: constexpr variable 'e' must be initialized
      by a constant expression
constexpr auto e = g();
               ^   ~~~
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:16: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:21: error: cannot take address of consteval function
      'f1' outside of an immediate invocation
constexpr auto e1 = f1;
                    ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:16: error: constexpr variable 'e1' must be initialized
      by a constant expression
constexpr auto e1 = f1;
               ^    ~~
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:16: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
4 errors generated.

These look like valid errors to me, so am I misunderstanding something? Is the concern that we're emitting error: constexpr variable '<whatever>' must be initialized by a constant expression after we already issued a diagnostic on the same line?

From my testing, there's more work to be done, but I think it can be done in a follow-up. Consider:

template <typename Ty>
struct S {
  consteval S() = default;
  Ty Val;
};

struct foo {
  foo();
};

S<int> s1; // Correctly rejected
S<foo> s2; // Incorrectly accepted

With this patch applied, s1 is correctly diagnosed, but s2 is not. The reason it's not is because Sema::CheckForImmediateInvocation() tests !Decl->isConsteval() to early return, and for the instantiation of S<foo>, the constructor is marked as "unspecified" rather than consteval. The reason for that is because we set DefaultedDefaultConstructorIsConstexpr to false at https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/DeclCXX.cpp#L1309 when instantiating the class. I think we may have some confusion where we mean "*IsConstexpr" to mean "is a constexpr function" or "is usable as a constexpr function", because my reading of https://eel.is/c++draft/dcl.constexpr#7 is that the instantiated template constructor IS a constexpr function but it is not usable in a constant expression. However, that might be orthogonal to the fixes here and should be done separately.

clang/lib/Parse/ParseDecl.cpp

2388

Is there a reason we're not moving this one to below AddInititializerToDecl() as we did elsewhere?

clang/lib/Sema/SemaDecl.cpp

14510 ↗

(On Diff #381416)

[Tyker]

In D74130#3085313, @aaron.ballman wrote:

FWIW, I am not seeing double errors on that code. Here's the output I get with this patch applied locally:

F:\source\llvm-project>cat "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp"
consteval int f1() { return 0; }
consteval auto g() { return f1; }

constexpr auto e = g();
constexpr auto e1 = f1;

F:\source\llvm-project>llvm\out\build\x64-Debug\bin\clang.exe -fsyntax-only -std=c++2b "C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp"
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:20: error: call to consteval function 'g' is not a
      constant expression
constexpr auto e = g();
                   ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:20: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:16: error: constexpr variable 'e' must be initialized
      by a constant expression
constexpr auto e = g();
               ^   ~~~
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:4:16: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:21: error: cannot take address of consteval function
      'f1' outside of an immediate invocation
constexpr auto e1 = f1;
                    ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:16: error: constexpr variable 'e1' must be initialized
      by a constant expression
constexpr auto e1 = f1;
               ^    ~~
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:5:16: note: pointer to a consteval declaration is not a
      constant expression
C:\Users\aballman\OneDrive - Intel Corporation\Desktop\test.cpp:1:15: note: declared here
consteval int f1() { return 0; }
              ^
4 errors generated.

These look like valid errors to me, so am I misunderstanding something? Is the concern that we're emitting error: constexpr variable '<whatever>' must be initialized by a constant expression after we already issued a diagnostic on the same line?

Yes, i think that
error: constexpr variable '<whatever>' must be initialized by a constant expression + call to consteval function '<whatever>' is not a constant expression or
error: constexpr variable '<whatever>' must be initialized by a constant expression + cannot take address of consteval function <whatever>' outside of an immediate invocation
is emitting 2 errors for the same root cause. the correct solution in my mind would be to swap too constant context when processing the initializer of a constexpr (or constinit) variable. this would disable consteval checking.

From my testing, there's more work to be done, but I think it can be done in a follow-up. Consider:

template <typename Ty>
struct S {
  consteval S() = default;
  Ty Val;
};

struct foo {
  foo();
};

S<int> s1; // Correctly rejected
S<foo> s2; // Incorrectly accepted

With this patch applied, s1 is correctly diagnosed, but s2 is not. The reason it's not is because Sema::CheckForImmediateInvocation() tests !Decl->isConsteval() to early return, and for the instantiation of S<foo>, the constructor is marked as "unspecified" rather than consteval. The reason for that is because we set DefaultedDefaultConstructorIsConstexpr to false at https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/DeclCXX.cpp#L1309 when instantiating the class. I think we may have some confusion where we mean "*IsConstexpr" to mean "is a constexpr function" or "is usable as a constexpr function", because my reading of https://eel.is/c++draft/dcl.constexpr#7 is that the instantiated template constructor IS a constexpr function but it is not usable in a constant expression. However, that might be orthogonal to the fixes here and should be done separately.

having a function that is explicitly specified consteval not returning true for isConsteval seems wrong.

IsConstexpr means the function has a either a consteval or constexpr(maybe implicit) specifier.
so i guess that "is a constexpr function" would be isConstexprSpecified
and "is usable as a constexpr function" would be isConstexpr

[Tyker]

clang/lib/Parse/ParseDecl.cpp

2388

yes, It was causing a few test failures, i didn't investigate much further.

clang/include/clang/Parse/Parser.h

void InitCXXThisScopeForDeclaratorIfRelevant(
       llvm::Optional<Sema::CXXThisScopeRAII> &ThisScope);
   bool ParseRefQualifier(bool &RefQualifierIsLValueRef,
                          SourceLocation &RefQualifierLoc);
   bool isFunctionDeclaratorIdentifierList();
   void ParseFunctionDeclaratorIdentifierList(
          Declarator &D,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
   void ParseParameterDeclarationClause(
-         DeclaratorContext DeclaratorContext,
-         ParsedAttributes &attrs,
-         SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
-         SourceLocation &EllipsisLoc);
+      DeclaratorContext DeclaratorContext, ParsedAttributes &attrs,
+      SourceLocation &EllipsisLoc, bool InConstantConstext = false);
   void ParseBracketDeclarator(Declarator &D);
   void ParseMisplacedBracketDeclarator(Declarator &D);
 
   //===--------------------------------------------------------------------===//
   // C++ 7: Declarations [dcl.dcl]
 
   /// The kind of attribute specifier we have found.
   enum CXX11AttributeKind {

clang/include/clang/Sema/Sema.h

struct ExpressionEvaluationContextRecord {
     ExpressionEvaluationContext Context;
 
     /// Whether the enclosing context needed a cleanup.
     CleanupInfo ParentCleanup;
 
     /// Whether we are in a decltype expression.
     bool IsDecltype;
 
+    enum ImmediateInvocationEndScopeAction {
+      IIESA_Handle, ///< Immediate invocation can and should be handeled at the
+                    ///< end of the scope.
+      IIESA_Propagate, ///< Immediate invocation cannot be handeled at the end
+                       ///< of the scope and should be propagated to the outer
+                       ///< scope.
+      IIESA_Drop, ///< Immediate invocation should be dropped at the end of the
+                  ///< scope.
+    } IIEndScopeAction = IIESA_Handle;
+
     /// The number of active cleanup objects when we entered
     /// this expression evaluation context.
     unsigned NumCleanupObjects;
 
     /// The number of typos encountered during this expression evaluation
     /// context (i.e. the number of TypoExprs created).
     unsigned NumTypos;
 
bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
                                         ObjCMethodDecl *Getter,
                                         SourceLocation Loc);
   void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
                              ArrayRef<Expr *> Args);
 
   void PushExpressionEvaluationContext(
       ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl = nullptr,
       ExpressionEvaluationContextRecord::ExpressionKind Type =
-          ExpressionEvaluationContextRecord::EK_Other);
+          ExpressionEvaluationContextRecord::EK_Other,
+      bool IsLambdaParamScope = false);
   enum ReuseLambdaContextDecl_t { ReuseLambdaContextDecl };
   void PushExpressionEvaluationContext(
       ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
       ExpressionEvaluationContextRecord::ExpressionKind Type =
           ExpressionEvaluationContextRecord::EK_Other);
   void PopExpressionEvaluationContext();
 
   void DiscardCleanupsInEvaluationContext();
class EnterExpressionEvaluationContext {
   bool Entered = true;
 
 public:
   EnterExpressionEvaluationContext(
       Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
       Decl *LambdaContextDecl = nullptr,
       Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
           Sema::ExpressionEvaluationContextRecord::EK_Other,
-      bool ShouldEnter = true)
+      bool ShouldEnter = true, bool IsLambdaParamScope = false)
       : Actions(Actions), Entered(ShouldEnter) {
     if (Entered)
       Actions.PushExpressionEvaluationContext(NewContext, LambdaContextDecl,
-                                              ExprContext);
+                                              ExprContext, IsLambdaParamScope);
   }
   EnterExpressionEvaluationContext(
       Sema &Actions, Sema::ExpressionEvaluationContext NewContext,
       Sema::ReuseLambdaContextDecl_t,
       Sema::ExpressionEvaluationContextRecord::ExpressionKind ExprContext =
           Sema::ExpressionEvaluationContextRecord::EK_Other)
       : Actions(Actions) {
     Actions.PushExpressionEvaluationContext(

clang/lib/Parse/ParseDecl.cpp

if (Tok.is(tok::kw_delete)) {
             << FixItHint::CreateReplacement(EqualLoc, ":");
         // We are trying to stop parser from looking for ';' in this for
         // statement, therefore preventing spurious errors to be issued.
         FRI->ColonLoc = EqualLoc;
         Init = ExprError();
         FRI->RangeExpr = Init;
       }
 
       InitScope.pop();
 
       if (Init.isInvalid()) {
         SmallVector<tok::TokenKind, 2> StopTokens;
         StopTokens.push_back(tok::comma);
         if (D.getContext() == DeclaratorContext::ForContext ||
             D.getContext() == DeclaratorContext::InitStmtContext)
           StopTokens.push_back(tok::r_paren);
         SkipUntil(StopTokens, StopAtSemi | StopBeforeMatch);
if (isFunctionDeclaratorIdentifierList()) {
     EndLoc = RParenLoc;
 
     // If there are attributes following the identifier list, parse them and
     // prohibit them.
     MaybeParseCXX11Attributes(FnAttrs);
     ProhibitAttributes(FnAttrs);
   } else {
     if (Tok.isNot(tok::r_paren))
-      ParseParameterDeclarationClause(D.getContext(), FirstArgAttrs, ParamInfo,
-                                      EllipsisLoc);
+      ParseParameterDeclarationClause(
+          D.getContext(), FirstArgAttrs, ParamInfo, EllipsisLoc,
+          D.getDeclSpec().getConstexprSpecifier() == CSK_consteval);
     else if (RequiresArg)
       Diag(Tok, diag::err_argument_required_after_attribute);
 
     HasProto = ParamInfo.size() || getLangOpts().CPlusPlus
                                 || getLangOpts().OpenCL;
 
     // If we have the closing ')', eat it.
     Tracker.consumeClose();

 /// [GNU]   declaration-specifiers declarator attributes
 ///         declaration-specifiers abstract-declarator[opt]
 /// [C++]   declaration-specifiers abstract-declarator[opt]
 ///           '=' assignment-expression
 /// [GNU]   declaration-specifiers abstract-declarator[opt] attributes
 /// [C++11] attribute-specifier-seq parameter-declaration
 ///
 void Parser::ParseParameterDeclarationClause(
-       DeclaratorContext DeclaratorCtx,
-       ParsedAttributes &FirstArgAttrs,
-       SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
-       SourceLocation &EllipsisLoc) {
+    DeclaratorContext DeclaratorCtx, ParsedAttributes &FirstArgAttrs,
+    SourceLocation &EllipsisLoc, bool InConstantConstext) {
 
   // Avoid exceeding the maximum function scope depth.
   // See https://bugs.llvm.org/show_bug.cgi?id=19607
   // Note Sema::ActOnParamDeclarator calls ParmVarDecl::setScopeInfo with
   // getFunctionPrototypeDepth() - 1.
   if (getCurScope()->getFunctionPrototypeDepth() - 1 >
       ParmVarDecl::getMaxFunctionScopeDepth()) {
     Diag(Tok.getLocation(), diag::err_function_scope_depth_exceeded)
if (DS.isEmpty() && ParmDeclarator.getIdentifier() == nullptr &&
         } else {
           // Consume the '='.
           ConsumeToken();
 
           // The argument isn't actually potentially evaluated unless it is
           // used.
           EnterExpressionEvaluationContext Eval(
               Actions,
-              Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed,
-              Param);
+              InConstantConstext
+                  ? Sema::ExpressionEvaluationContext::ConstantEvaluated
+                  : Sema::ExpressionEvaluationContext::
+                        PotentiallyEvaluatedIfUsed,
+              Param, Sema::ExpressionEvaluationContextRecord::EK_Other,
+              /*ShouldEnter*/ true,
+              DeclaratorCtx == DeclaratorContext::LambdaExprContext);
 
           ExprResult DefArgResult;
           if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
             Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
             DefArgResult = ParseBraceInitializer();
           } else
             DefArgResult = ParseAssignmentExpression();
           DefArgResult = Actions.CorrectDelayedTyposInExpr(DefArgResult);

clang/lib/Sema/SemaDeclCXX.cpp

if (S && D->isOutOfLine())
     EnterDeclaratorContext(S, D->getDeclContext());
 
   // If we are parsing the initializer for a static data member, push a
   // new expression evaluation context that is associated with this static
   // data member.
   if (isNonlocalVariable(D))
     PushExpressionEvaluationContext(
         ExpressionEvaluationContext::PotentiallyEvaluated, D);
+
+  bool HasConstantInitializer = false;
+  if (auto *VD = dyn_cast<VarDecl>(D))
+    HasConstantInitializer = VD->isConstexpr() || VD->hasAttr<ConstInitAttr>();
+  isConstantEvaluatedOverride = HasConstantInitializer;
 }
 
 /// Invoked after we are finished parsing an initializer for the declaration D.
 void Sema::ActOnCXXExitDeclInitializer(Scope *S, Decl *D) {
   // If there is no declaration, there was an error parsing it.
   if (!D || D->isInvalidDecl())
     return;
 
   if (isNonlocalVariable(D))
     PopExpressionEvaluationContext();
 
   if (S && D->isOutOfLine())
     ExitDeclaratorContext(S);
+  isConstantEvaluatedOverride = false;
 }
 
 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
 /// C++ if/switch/while/for statement.
 /// e.g: "if (int x = f()) {...}"
 DeclResult Sema::ActOnCXXConditionDeclaration(Scope *S, Declarator &D) {
   // C++ 6.4p2:
   // The declarator shall not specify a function or an array.

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::TransformToPotentiallyEvaluated(Expr *E) {
   if (isUnevaluatedContext())
     return E;
   return TransformToPE(*this).TransformExpr(E);
 }
 
 void
 Sema::PushExpressionEvaluationContext(
     ExpressionEvaluationContext NewContext, Decl *LambdaContextDecl,
-    ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
+    ExpressionEvaluationContextRecord::ExpressionKind ExprContext,
+    bool IsLambdaParamScope) {
   ExprEvalContexts.emplace_back(NewContext, ExprCleanupObjects.size(), Cleanup,
                                 LambdaContextDecl, ExprContext);
   Cleanup.reset();
+  if (IsLambdaParamScope)
+    ExprEvalContexts.back().IIEndScopeAction =
+        Sema::ExpressionEvaluationContextRecord::IIESA_Propagate;
   if (!MaybeODRUseExprs.empty())
     std::swap(MaybeODRUseExprs, ExprEvalContexts.back().SavedMaybeODRUseExprs);
 }
 
 void
 Sema::PushExpressionEvaluationContext(
     ExpressionEvaluationContext NewContext, ReuseLambdaContextDecl_t,
     ExpressionEvaluationContextRecord::ExpressionKind ExprContext) {
if (BO->getOpcode() == BO_Assign) {
       LHSs.erase(std::remove(LHSs.begin(), LHSs.end(), BO->getLHS()),
                  LHSs.end());
     }
   }
 }
 
 ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
   if (!E.isUsable() || !Decl || !Decl->isConsteval() || isConstantEvaluated() ||
-      RebuildingImmediateInvocation)
+      RebuildingImmediateInvocation ||
+      ExprEvalContexts.back().IIEndScopeAction ==
+          ExpressionEvaluationContextRecord::IIESA_Drop)
     return E;
 
   /// Opportunistically remove the callee from ReferencesToConsteval if we can.
   /// It's OK if this fails; we'll also remove this in
   /// HandleImmediateInvocations, but catching it here allows us to avoid
   /// walking the AST looking for it in simple cases.
   if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
     if (auto *DeclRef =
if (!CE->EvaluateAsConstantExpr(Eval, Expr::EvaluateForCodeGen,
     else if (auto *Call = dyn_cast<CXXConstructExpr>(InnerExpr))
       FD = Call->getConstructor();
     else
       llvm_unreachable("unhandled decl kind");
     assert(FD->isConsteval());
     SemaRef.Diag(CE->getBeginLoc(), diag::err_invalid_consteval_call) << FD;
     for (auto &Note : Notes)
       SemaRef.Diag(Note.first, Note.second);
     return;
   }
   CE->MoveIntoResult(Eval.Val, SemaRef.getASTContext());
 }
 
 static void RemoveNestedImmediateInvocation(
     Sema &SemaRef, Sema::ExpressionEvaluationContextRecord &Rec,
     SmallVector<Sema::ImmediateInvocationCandidate, 4>::reverse_iterator It) {
   struct ComplexRemove : TreeTransform<ComplexRemove> {
static void RemoveNestedImmediateInvocation(
   It->getPointer()->setSubExpr(Res.get());
 }
 
 static void
 HandleImmediateInvocations(Sema &SemaRef,
                            Sema::ExpressionEvaluationContextRecord &Rec) {
   if ((Rec.ImmediateInvocationCandidates.size() == 0 &&
        Rec.ReferenceToConsteval.size() == 0) ||
-      SemaRef.RebuildingImmediateInvocation)
+      SemaRef.RebuildingImmediateInvocation ||
+      Rec.IIEndScopeAction ==
+          Sema::ExpressionEvaluationContextRecord::IIESA_Drop)
+    return;
+
+  /// If we can't handle immediate invocations yet. add them to the outer scope.
+  /// This occurs for default argument of lambdas as we can't know if the lambda
+  /// is consteval until after the parameter context has been poped.
+  if (Rec.IIEndScopeAction ==
+      Sema::ExpressionEvaluationContextRecord::IIESA_Propagate) {
+    assert(SemaRef.ExprEvalContexts.size() >= 2);
+    (SemaRef.ExprEvalContexts.rbegin() + 1)
+        ->ImmediateInvocationCandidates.append(
+            Rec.ImmediateInvocationCandidates.begin(),
+            Rec.ImmediateInvocationCandidates.end());
+    (SemaRef.ExprEvalContexts.rbegin() + 1)
+        ->ReferenceToConsteval.insert(Rec.ReferenceToConsteval.begin(),
+                                      Rec.ReferenceToConsteval.end());
     return;
+  }
 
   /// When we have more then 1 ImmediateInvocationCandidates we need to check
   /// for nested ImmediateInvocationCandidates. when we have only 1 we only
   /// need to remove ReferenceToConsteval in the immediate invocation.
   if (Rec.ImmediateInvocationCandidates.size() > 1) {
 
     /// Prevent sema calls during the tree transform from adding pointers that
     /// are already in the sets.
     llvm::SaveAndRestore<bool> DisableIITracking(
         SemaRef.RebuildingImmediateInvocation, true);

clang/lib/Sema/SemaLambda.cpp

 }
 
 void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
                                         Declarator &ParamInfo,
                                         Scope *CurScope) {
   LambdaScopeInfo *const LSI = getCurLambda();
   assert(LSI && "LambdaScopeInfo should be on stack!");
 
+  if (ParamInfo.getDeclSpec().getConstexprSpecifier() == CSK_consteval)
+    ExprEvalContexts.back().IIEndScopeAction =
+        ExpressionEvaluationContextRecord::IIESA_Drop;
+
   // Determine if we're within a context where we know that the lambda will
   // be dependent, because there are template parameters in scope.
   bool KnownDependent;
   if (LSI->NumExplicitTemplateParams > 0) {
     auto *TemplateParamScope = CurScope->getTemplateParamParent();
     assert(TemplateParamScope &&
            "Lambda with explicit template param list should establish a "
            "template param scope");
     assert(TemplateParamScope->getParent());
     KnownDependent = TemplateParamScope->getParent()
                                        ->getTemplateParamParent() != nullptr;
   } else {

clang/test/SemaCXX/cxx2a-consteval.cpp

 auto l1 = [](int i) constexpr {
 // expected-note@-1 {{declared here}}
   int t = f(i);
 // expected-error@-1 {{is not a constant expression}}
 // expected-note@-2 {{read of non-const variable}}
   return f(0);  
 };
 
+consteval int f1() {
+// expected-note@-1+ {{declared here}}
+  return 0;
+}
+consteval auto g() { return f1; }
+consteval int h(int (*p)() = g()) { return p(); }
+int h1(int (*p)() = g()) { return p(); }
+// expected-error@-1 {{is not a constant expression}}
+// expected-note@-2 {{pointer to a consteval}}
+
+constexpr auto e = g();
+// expected-error@-1 {{must be initialized by a constant expression}}
+// expected-note@-2 {{is not a constant expression}}
+
+auto l = [](int (*p)() = g()) { return p(); };
+// expected-error@-1 {{is not a constant expression}}
+// expected-note@-2 {{pointer to a consteval}}
+
+auto l2 = [](int (*p)() = g()) consteval { return p(); };
+
 }
 
 namespace std {
 
 template <typename T> struct remove_reference { using type = T; };
 template <typename T> struct remove_reference<T &> { using type = T; };
 template <typename T> struct remove_reference<T &&> { using type = T; };