[C++20] Add consteval-specific semantic for functions

[Tyker]

Summary

Changes:

• Calls to consteval function and constructors are not evaluated as soon as they are reached.
• Add diagnostic for taking address of a consteval function in non-constexpr context.
• Add diagnostic for address of consteval function accessible at runtime.
• Add tests

Serialization and importing depends on https://reviews.llvm.org/D63640

[Tyker]

ping @rsmith

[Tyker]

@rsmith ping

[Tyker]

ping @rsmith

[Tyker]

Rebased

@rsmith Ping

[rsmith]

clang/include/clang/Basic/DiagnosticSemaKinds.td

2314

Let's use the proper terminology here so people can search for it: "outside of an immediate invocation"

2315–2317

This diagnostic should be moved to DiagnosticASTKinds (and produced by CheckConstantExpression; see my other comment on this). Please rephrase this to follow the same pattern as note_constexpr_non_global.

clang/lib/Sema/SemaExpr.cpp

5595–5599

This should be checked when determining whether the core constant expression is a constant expression, which happens in CheckConstantExpression in ExprConstant.cpp, not here.

[rsmith]

clang/include/clang/Basic/DiagnosticSemaKinds.td

2321

"consteval specified" -> "declared consteval"

3743–3744

consteval should not affect overload resolution. I don't think this diagnostic makes sense. (We should first pick the function and *then* check whether it's usable.)

clang/include/clang/Sema/Sema.h

2120

This should be called CheckImmediateInvocation or similar. ActOn* functions should only be called by the parser in response to source constructs, not internally by Sema.

clang/lib/Sema/SemaDeclCXX.cpp

2113–2115

Please keep lines to 80 columns or fewer.

clang/lib/Sema/SemaExpr.cpp

5582–5587

I don't think this approach can work as-is. You need to know the complete bounds of the immediate invocation before you can check it. For example:

enum E {};
consteval int operator+(int (*f)(), E) { return f(); }
consteval int fn() { return 42; }
consteval auto get() -> int(*)() { return fn; }

int k = get() + E();

This is (or at least should be) valid code: the immediate invocation here is the entire get() + E() expression, and evaluating that produces 42. But this approach will reject the code, because get() in isolation is a constant expression. (The current wording suggests that this code is invalid, but I'm trying to get that fixed; I'm confident that was not the intent.)

I think we need a different approach. Perhaps:

• when we see a candidate immediate invocation, immediately create a ConstantExpr wrapping it, but don't evaluate it yet
• add that ConstantExpr to a list on the expression evaluation context record
• if there already were any expressions listed there, check to see if any of them is a subexpression of the current expression, and if so, perform a TreeTransform to remove the ConstantExpr wrappers from those subexpressions and remove them from the list on the evaluation context record
• when we pop an expression evaluation context record, *then* evaluate all remaining ConstantExprs for immediate invocations and check they're valid

(Or some other approach that handles this wrinkle; the above is just a suggestion.)

5603

This is the wrong place to call ActOnConstevalCall from: that needs to happen when we actually build the resolved call expression (which isn't always done by this function).

5624–5625

!isConstantEvaluated() should be checked in the CXXConstructExpr case too; consider moving that check into ActOnConstevalCall.

5744–5746

What's the purpose of this change?

clang/lib/Sema/SemaOverload.cpp

9595–9606

This isn't the right way to deal with this, in part because we don't know whether we're in an immediate invocation or not at this point. Instead, we should track that we saw a use of a consteval function from Sema::DiagnoseUseOfDecl, and issue a diagnostic if that use is not within an immediate invocation / within a consteval function.

[Tyker]

sorry i didn't realize the full complexity of immediate invocations.
i am working on a patch fixing issues.

clang/lib/Sema/SemaExpr.cpp

5744–5746

this change was to prevent a double error message for code like:

consteval f() { return 0; }
auto* p = __builtin_addressof(f);

it is going to disappear because the error reporting locations are going to move.

clang/lib/Sema/SemaOverload.cpp

9595–9606

from what i understood Sema::DiagnoseUseOfDecl is called as soon as the Decl is used. but there is some cases similar to the one you gave in an other comment where we can't know yet if the use is during an immediate invokation. like the following

enum E {};
consteval int operator+(int (*f)(), E) { return f(); }
consteval int fn() { return 42; }

int k = &fn + E();

this should be valid i think. but at the point of call of Sema::DiagnoseUseOfDecl for the use of fn we don't know yet that we are in an immediate invokation. so i think this check should be delayed until we know the bounds of the immediate invokation.

[Tyker]

I narrowed the patch because it was getting quite big. this patch only handle consteval function, not constructors.

Changes:

• keep track of DeclRefExpr on consteval decaltions.
• keep track of candidates for immediate invocation.
• detect and remove nested immediate invocation candidates
• detect and remove DeclRefExpr on consteval declarations inside immediate invocations.
• diagnose non removed DeclRefExpr on consteval declarations and candidates for immediate invocation.
• fixe existing bug where defaulted special members declared consteval where marked constexpr instead.
• improve tests.

[Tyker]

Changes:

• Rebased
• Fixed typos

[Tyker]

@rsmith Ping

[Tyker]

ping @rsmith

[rsmith]

Very cool, this is an elegant approach.

clang/include/clang/Basic/DiagnosticASTKinds.td

57 ↗

(On Diff #219240)

on -> to

clang/include/clang/Basic/DiagnosticSemaKinds.td

2319

Please add 's around the function name. Instead of encoding the name as an integer, you can stream the declaration itself into the diagnostic and just use "%0 cannot be declared consteval" here.

clang/include/clang/Sema/Sema.h

800–802

The comment should first describe what this field means, before saying how to use it (if necessary). So:

/// Whether immediate invocation candidates and references to consteval functions should be tracked.

or something like that.

That said, consider renaming this to RebuildingImmediateInvocation to avoid suggesting it's a general mechanism to turn off immediate invocation tracking.

1061

ImmediateInvocationsCandidates -> ImmediateInvocationCandidates

1065

ReferenceOnConsteval -> ReferencesToConsteval or similar.

clang/lib/AST/ExprConstant.cpp

1932 ↗

(On Diff #219240)

It would be useful for the diagnostic to say what consteval function we have a pointer to, and maybe include a note pointing at its declaration.

clang/lib/Sema/SemaDeclCXX.cpp

11044–11045

I don't think this is necessary: implicit special members are never consteval. (We use DeclareImplicitDefaultConstructor when there is no user-declared default constructor, in which case there can't possibly be a defaulted consteval default constructor.) I don't think you need any of the DetermineSpecialMemberConstexprKind machinery, nor the tracking of DefaultedSpecialMemberIsConsteval in CXXRecordDecl.

clang/lib/Sema/SemaExpr.cpp

14820

Consider using E.get()->IgnoreImplicit() here; we want to step over (at least) any CXXBindTemporaryExprs inserted by MaybeBindToTemporary.

14820–14823

Please add a comment to this to point out that it's just an optimization, for example:

"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."

14824–14827

We will need an ExprWithCleanups wrapping E.get() if there might be any temporaries within it.

We don't actually know whether there definitely are any such temporaries, but we can conservatively assume we might need an ExprWithCleanups if Cleanup.exprNeedsCleanups() returns true.

You can test this with something like:

struct A { int *p = new int(42); consteval int get() { return *p; } constexpr ~A() { delete p; } };
int k = A().get();

... which should be valid, but will be rejected (or might assert) if we don't destroy the A() temporary as part of evaluating the consteval call to get.

14859

< on SourceLocation doesn't really mean anything. It's not correct to use it here. Also, using source locations will not give you outer expressions before inner ones. Consider:

enum E {};
consteval E f();
consteval int operator+(E, int);
void g() {
  f() + 1;
}

Here, the begin location of both the call to f() and the call to operator+ are in the same place: at the f token.

I don't think you need this sort at all: instead, you can process immediate invocations in ImmediateInvocationCandidates in reverse order: subexpressions must have been built before their enclosing expressions, so walking in reverse order will guarantee that you process an outer candidate before any inner ones.

14890

We should look for an exact match here, not merely for something nearby. (Maybe: form a pointer set of immediate invocation pointer expressions, and remove things from the set when you encounter them in this walk; then when iterating over the immediate invocations, skip ones that have already been erased from the set.)

14906–14907

I don't imagine this will ever actually happen, because immutability of the AST is so important to other parts of Clang. This should be a rare case, so it likely doesn't matter; I'd just remove this FIXME.

[Tyker]

almost all comments were addressed.

clang/lib/Sema/SemaDeclCXX.cpp

11044–11045

all the code you mention is to fixe an issue i saw while working on consteval.
the AST of

struct A {
    consteval A() = default;
    consteval A(int) { }
};

is

TranslationUnitDecl
`-CXXRecordDecl <line:1:1, line:4:1> line:1:8 struct A definition
  |-DefinitionData pass_in_registers empty standard_layout trivially_copyable trivial literal has_user_declared_ctor has_constexpr_non_copy_move_ctor can_const_default_init
  | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr
  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param
  | |-MoveConstructor exists simple trivial needs_implicit
  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param
  | |-MoveAssignment exists simple trivial needs_implicit
  | `-Destructor simple irrelevant trivial needs_implicit
  |-CXXRecordDecl <col:1, col:8> col:8 implicit referenced struct A
  |-CXXConstructorDecl <line:2:5, col:27> col:15 constexpr A 'void ()' default trivial noexcept-unevaluated 0x55585ae25160
  `-CXXConstructorDecl <line:3:5, col:24> col:15 consteval A 'void (int)'
    |-ParmVarDecl <col:17> col:20 'int'
    `-CompoundStmt <col:22, col:24>

godbolt
notice that A::A() is marked as constexpr instead of consteval.
and A::A(int) is marked correctly.

this is because consteval defaulted special members are not marked as consteval.
those code changes are intended to fix that. with this patch both constructor are marked as consteval

clang/lib/Sema/SemaExpr.cpp

14859

the sort is used in combination with a lower_bounds in ComplexRemove::TransformConstantExpr to lookup in ImmediateInvocationsCandidates using binary search.
but i think your proposition is more efficient except in some very rare cases.

14890

the issue i had with a set is that we can't remove element during iteration as removing element invalidate iterators.
but to get an exact match we can use the pointer as "key", they are unique.

[Tyker]

improve performance in a bad case

[Tyker]

The now that constexpr destructors are legal. The code in this patch need to be adapted, I have question about the following code.

struct A {
  constexpr ~A() {}
};

consteval A f() {
    return A{};
}

void test() {
    A a;
    a = f(); // <-- here
}

At the point i marked.
The invocation of f causes an immediate invocation (http://eel.is/c++draft/expr.const#12).
Immediate invocation are full expression (http://eel.is/c++draft/intro.execution#5).
Full expression resolve all there side-effects before evaluating the next full expression (http://eel.is/c++draft/intro.execution#9).
The return value of f() is created inside the immediate invocation.
So the destructor of the value returned by f() should be destroyed within the immediate evaluation.
But that value is needed for the assignment operator.
This seem contradictory. What have i misunderstood ? What should happen here ?

[Tyker]

ping @rsmith

[Tyker]

ping @rsmith

[rsmith]

In D63960#1712398, @Tyker wrote:

The now that constexpr destructors are legal. The code in this patch need to be adapted, I have question about the following code.

struct A {
  constexpr ~A() {}
};

consteval A f() {
    return A{};
}

void test() {
    A a;
    a = f(); // <-- here
}

At the point i marked.
The invocation of f causes an immediate invocation (http://eel.is/c++draft/expr.const#12).
Immediate invocation are full expression (http://eel.is/c++draft/intro.execution#5).
Full expression resolve all there side-effects before evaluating the next full expression (http://eel.is/c++draft/intro.execution#9).
The return value of f() is created inside the immediate invocation.
So the destructor of the value returned by f() should be destroyed within the immediate evaluation.
But that value is needed for the assignment operator.
This seem contradictory. What have i misunderstood ? What should happen here ?

After desugaring, the above example looks like this:

a.operator=( <temporary materialization conversion>( <consteval full-expression>( f() ) ) );

That is: the temporary is materialized outside the immediate evaluation, so no A destructor should be run as part of evaluating that full-expression (the destructor is run in the enclosing full-expression). If the example were instead:

constexpr A g() {
  return A {};
}
consteval A &id (A &&a) { return a; }

void test() {
  A a;
  a = id(g());
}

then we would have

a.operator=( <consteval full-expression>( id( <temporary materialization conversion>( g() ) ) ) );

... and now the A temporary should be destroyed inside the full-expression. This example is ill-formed because the id call is not a constant expression (because its evaluated value refers to an object with automatic storage duration).

[Tyker]

@rsmith

Changes:

• Rebased on recent master.
• Adapted this patch to constexpr destructors.
• Fixed issues with handling of temporaries.
• Improve Tests.

[Tyker]

minor fixes
improved tests

[Tyker]

@rsmith ping

[Tyker]

@rsmith ping

[rsmith]

clang/include/clang/AST/Expr.h

1033–1035 ↗

(On Diff #228197)

I'd remove the "CausedBy" here -- the ConstantExpr is our representation of the immediate invocation.

Also, please start this function name with a lowercase i for local consistency.

clang/include/clang/Sema/Sema.h

1011

II doesn't mean anything to a reader here; please expand the abbreviation.

5197–5198

potention -> potential
Missing period at end of sentence.

clang/lib/AST/ExprConstant.cpp

2012–2013 ↗

(On Diff #228197)

Please add braces to these if statements (their controlled statement is too long to omit the braces). As a general rule: if an inner construct needs braces, put braces on the outer constructs too.

13618 ↗

(On Diff #228197)

This isn't sufficient: the evaluation process can refer back to the object under construction (eg, via this), and we need an lvalue that actually names the result in order for this to work.

I think you'll need to do something like creating a suitable object (perhaps a LifetimeExtendedTemporaryDecl) in the caller to represent the result of the immediate invocation, and passing that into here.

clang/lib/Sema/Sema.cpp

164 ↗

(On Diff #228197)

Consider using a default member initializer instead.

clang/lib/Sema/SemaDecl.cpp

8646–8647

Please add braces here.

8647

This rule also applies to non-member allocator functions. (Don't check for a CXXMethodDecl here.)

clang/lib/Sema/SemaDeclCXX.cpp

11044–11045

This change is incorrect: an implicit special member is never consteval. (Note that implicit special members are the ones the compiler declares for you, not the ones you get from = default.) We don't need this, and as a consequence we don't need DefaultedSpecialMemberIsConsteval on DefinitionData.

clang/lib/Sema/SemaExpr.cpp

14854

This is unreachable; a CXXMemberCallExpr is a CallExpr so this was already handled above. Can you just delete this case?

14859

Typo unhandeld -> unhandled

14910

Transfromer -> Transformer

clang/lib/Sema/TreeTransform.h

3451–3452 ↗

(On Diff #228197)

I'm surprised that we can remove this; I'd expect this to be necessary to properly handle transforming cases such as

struct X { X(int); ~X(); int n; };
struct Y { explicit Y(int); };
template<typename T> void f() {
  Y y(X(sizeof(sizeof(T))).n);
}
template void f<int>();

... where we need to strip off an ExprWithCleanups to find the syntactic initializer inside it.

If you want to special-case this from ComplexRemove, to make sure you see all ConstantExprs, can you override TransformInitializer there instead of changing it globally?

[Tyker]

comments were fixed.

clang/lib/AST/ExprConstant.cpp

13618 ↗

(On Diff #228197)

i believe this solution should work. without LifetimeExtendedTemporaryDecl because reference/pointer on temporaries are not valid results of constant evaluation. so the AST should never store an APValue whose LValue is a ConstantExpr.

[Tyker]

ping @rsmith

[Tyker]

ping @rsmith

[Tyker]

@rsmith friendly reminder

[Tyker]

@aaron.ballman do you think you can review this ?

[rsmith]

Some nits and very minor things, but I think this is generally good to go with those fixed. Sorry for the long review delay, and thanks for working on it!

clang/include/clang/Basic/DiagnosticSemaKinds.td

2317

could not be evaluated -> is not a constant expression

clang/include/clang/Sema/Sema.h

800

rebuild -> rebuilt

1059

candidate -> candidates

1062

DeclRefExpr -> DeclRefExprs

1063

know -> known

clang/lib/AST/ExprConstant.cpp

13618 ↗

(On Diff #228197)

OK, I think that should be fine. Please update the comment above class LValueExprEvaluator to describe this additional case.

clang/lib/Sema/SemaDecl.cpp

8642

In C++20, we should probably reset to constexpr rather than unspecified. Before C++20, it's better for error recovery to leave the function as constexpr. (So unconditionally using CSK_constexpr here would be OK.)

clang/lib/Sema/SemaExpr.cpp

14861

You can use `"%q0" to get a qualified name in a diagnostic; you don't need to turn it into a string yourself.

[Tyker]

thank you for the review.
i am sorry there were so many back and forth.

[ldionne]

@Tyker @rsmith You might be interested in reading https://llvm.org/PR45912, which describes what I believe to be an issue with this patch (or another related patch for consteval -- not sure).

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def warn_cxx98_compat_constexpr : Warning<
   "'constexpr' specifier is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 // FIXME: Maybe this should also go in -Wc++14-compat?
 def warn_cxx14_compat_constexpr_not_const : Warning<
   "'constexpr' non-static member function will not be implicitly 'const' "
   "in C++14; add 'const' to avoid a change in behavior">,
   InGroup<DiagGroup<"constexpr-not-const">>;
+def err_invalid_consteval_take_address : Error<
+  "cannot take address of consteval function %0 in non-constexpr context">;
+def err_consteval_address_accessible : Error<
+  "%select{return value|constructed object}0 contain pointer on consteval declaration;"
+  " this would make it accessible at runtime">;
+def err_invalid_consteval_call : Error<
+  "call to consteval %select{function|constructor of}1 %0 could not be evaluated">;
+def err_invalid_consteval_decl_kind : Error<
+  "operator %select{new|delete|new[]|delete[]}0 cannot be consteval specified">;
 def err_invalid_constexpr : Error<
   "%select{function parameter|typedef|non-static data member}0 "
   "cannot be %select{constexpr|consteval}1">;
 def err_invalid_constexpr_member : Error<"non-static data member cannot be "
   "constexpr%select{; did you intend to make it %select{const|static}0?|}1">;
 def err_constexpr_tag : Error<
   "%select{class|struct|interface|union|enum}0 "
   "cannot be marked %select{constexpr|consteval}1">;
def err_constexpr_local_var_static : Error<
   "%select{function|constructor}0">;
 def err_constexpr_local_var_non_literal_type : Error<
   "variable of non-literal type %1 cannot be defined in a constexpr "
   "%select{function|constructor}0">;
 def err_constexpr_local_var_no_init : Error<
   "variables defined in a constexpr %select{function|constructor}0 must be "
   "initialized">;
 def ext_constexpr_function_never_constant_expr : ExtWarn<
-  "constexpr %select{function|constructor}0 never produces a "
+  "%select{constexpr|consteval}1 %select{function|constructor}0 never produces a "
   "constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError;
 def err_attr_cond_never_constant_expr : Error<
   "%0 attribute expression never produces a constant expression">;
 def err_diagnose_if_invalid_diagnostic_type : Error<
   "invalid diagnostic type for 'diagnose_if'; use \"error\" or \"warning\" "
   "instead">;
 def err_constexpr_body_no_return : Error<
   "no return statement in %select{constexpr|consteval}0 function">;

 def warn_cxx17_compat_constexpr_function_try_block : Warning<
   "function try block in constexpr %select{function|constructor}0 is "
   "incompatible with C++ standards before C++2a">,
   InGroup<CXXPre2aCompat>, DefaultIgnore;
 
 def err_constexpr_union_ctor_no_init : Error<
   "constexpr union constructor does not initialize any member">;
 def err_constexpr_ctor_missing_init : Error<
-  "constexpr constructor must initialize all members">;
+  "%select{constexpr|consteval}0 constructor must initialize all members">;
 def note_constexpr_ctor_missing_init : Note<
   "member not initialized by constructor">;
 def note_non_literal_no_constexpr_ctors : Note<
   "%0 is not literal because it is not an aggregate and has no constexpr "
   "constructors other than copy or move constructors">;
 def note_non_literal_base_class : Note<
   "%0 is not literal because it has base class %1 of non-literal type">;
 def note_non_literal_field : Note<
def note_ovl_candidate_disabled_by_function_cond_attr : Note<
     "candidate disabled: %0">;
 def note_ovl_candidate_disabled_by_extension : Note<
     "candidate unavailable as it requires OpenCL extension '%0' to be enabled">;
 def err_addrof_function_disabled_by_enable_if_attr : Error<
     "cannot take address of function %0 because it has one or more "
     "non-tautological enable_if conditions">;
 def note_addrof_ovl_candidate_disabled_by_enable_if_attr : Note<
     "candidate function made ineligible by enable_if">;
+def note_addrof_ovl_consteval : Note<
+    "candidate function made ineligible by consteval specifier">;
 def note_ovl_candidate_deduced_mismatch : Note<
     "candidate template ignored: deduced type "
     "%diff{$ of %select{|element of }4%ordinal0 parameter does not match "
     "adjusted type $ of %select{|element of }4argument"
     "|of %select{|element of }4%ordinal0 parameter does not match "
     "adjusted type of %select{|element of }4argument}1,2%3">;
 def note_ovl_candidate_non_deduced_mismatch : Note<
     "candidate template ignored: could not match %diff{$ against $|types}0,1">;

clang/include/clang/Sema/Sema.h

void pop() {
       SavedContext = nullptr;
     }
 
     ~ContextRAII() {
       pop();
     }
   };
 
   /// Used to change context to isConstantEvaluated without pushing a heavy
   /// ExpressionEvaluationContextRecord object.
   bool isConstantEvaluatedOverride;
 
   bool isConstantEvaluated() {
     return ExprEvalContexts.back().isConstantEvaluated() ||
            isConstantEvaluatedOverride;
   }
 
   /// RAII object to handle the state changes required to synthesize
   /// a function body.
enum class ExpressionEvaluationContext {
     ///
     /// This value is used when parsing default function arguments, for which
     /// we would like to provide diagnostics (e.g., passing non-POD arguments
     /// through varargs) but do not want to mark declarations as "referenced"
     /// until the default argument is used.
     PotentiallyEvaluatedIfUsed
   };
 
   /// Data structure used to record current or nested
   /// expression evaluation contexts.
   struct ExpressionEvaluationContextRecord {
     /// The expression evaluation context.
     ExpressionEvaluationContext Context;
 
     /// Whether the enclosing context needed a cleanup.
     CleanupInfo ParentCleanup;
 
struct ExpressionEvaluationContextRecord {
     SmallVector<CallExpr *, 8> DelayedDecltypeCalls;
 
     /// If we are processing a decltype type, a set of temporary binding
     /// expressions for which we have deferred checking the destructor.
     SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;
 
     llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;
 
     /// \brief Describes whether we are in an expression constext which we have
     /// to handle differently.
     enum ExpressionKind {
       EK_Decltype, EK_TemplateArgument, EK_Other
     } ExprContext;
 
     ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
                                       unsigned NumCleanupObjects,
                                       CleanupInfo ParentCleanup,
                                       Decl *ManglingContextDecl,
                                       ExpressionKind ExprContext)
         : Context(Context), ParentCleanup(ParentCleanup),
           NumCleanupObjects(NumCleanupObjects), NumTypos(0),
           ManglingContextDecl(ManglingContextDecl), MangleNumbering(),
           ExprContext(ExprContext) {}
public:
   void ActOnParamDefaultArgumentError(Decl *param, SourceLocation EqualLoc);
   bool SetParamDefaultArgument(ParmVarDecl *Param, Expr *DefaultArg,
                                SourceLocation EqualLoc);
 
   void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit);
   void ActOnUninitializedDecl(Decl *dcl);
   void ActOnInitializerError(Decl *Dcl);
 
+  ExprResult ActOnConstevalCall(FunctionDecl *FD, Expr *Call);
+
   void ActOnPureSpecifier(Decl *D, SourceLocation PureSpecLoc);
   void ActOnCXXForRangeDecl(Decl *D);
   StmtResult ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
                                         IdentifierInfo *Ident,
                                         ParsedAttributes &Attrs,
                                         SourceLocation AttrEnd);
   void SetDeclDeleted(Decl *dcl, SourceLocation DelLoc);
   void SetDeclDefaulted(Decl *dcl, SourceLocation DefaultLoc);
public:
   /// \returns true if an error occurred.
   bool checkThisInStaticMemberFunctionAttributes(CXXMethodDecl *Method);
 
   /// MaybeBindToTemporary - If the passed in expression has a record type with
   /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
   /// it simply returns the passed in expression.
   ExprResult MaybeBindToTemporary(Expr *E);
 
   bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
                                MultiExprArg ArgsPtr,
                                SourceLocation Loc,
                                SmallVectorImpl<Expr*> &ConvertedArgs,
                                bool AllowExplicit = false,
                                bool IsListInitialization = false);
 
   ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
                                           SourceLocation NameLoc,
                                           IdentifierInfo &Name);

clang/lib/Sema/SemaDecl.cpp

if (ConstexprKind != CSK_unspecified) {
       // are implicitly inline.
       NewFD->setImplicitlyInline();
 
       // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
       // be either constructors or to return a literal type. Therefore,
       // destructors cannot be declared constexpr.
       if (isa<CXXDestructorDecl>(NewFD))
         Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
             << (ConstexprKind == CSK_consteval);
+      // C++20 [dcl.constexpr]p2: A destructor, an allocation function, or a
+      // deallocation function shall not be declared with the consteval
+      // specifier.
+      if (ConstexprKind == CSK_consteval) {
+        if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD)) {
+          if (MD->getOverloadedOperator() == OO_New ||
+              MD->getOverloadedOperator() == OO_Array_New ||
+              MD->getOverloadedOperator() == OO_Delete ||
+              MD->getOverloadedOperator() == OO_Array_Delete) {
+            Diag(D.getDeclSpec().getConstexprSpecLoc(),
+                 diag::err_invalid_consteval_decl_kind)
+                << MD->getOverloadedOperator() - OO_New;
+            NewFD->setConstexprKind(CSK_constexpr);
+          }
+        }
+      }
     }
 
     // If __module_private__ was specified, mark the function accordingly.
     if (D.getDeclSpec().isModulePrivateSpecified()) {
       if (isFunctionTemplateSpecialization) {
         SourceLocation ModulePrivateLoc
           = D.getDeclSpec().getModulePrivateSpecLoc();
         Diag(ModulePrivateLoc, diag::err_module_private_specialization)
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))
-    PushExpressionEvaluationContext(ExprEvalContexts.back().Context);
+    PushExpressionEvaluationContext(
+        FD->isConsteval() ? ExpressionEvaluationContext::ConstantEvaluated
+                          : 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();
   }
   if (const auto *Attr = FD->getAttr<IFuncAttr>()) {

clang/lib/Sema/SemaDeclCXX.cpp

static void CheckConstexprCtorInitializer(Sema &SemaRef,
   if (Field->isAnonymousStructOrUnion() &&
       (Field->getType()->isUnionType()
            ? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()
            : Field->getType()->getAsCXXRecordDecl()->isEmpty()))
     return;
 
   if (!Inits.count(Field)) {
     if (!Diagnosed) {
-      SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init);
+      SemaRef.Diag(Dcl->getLocation(), diag::err_constexpr_ctor_missing_init)
+          << Dcl->isConsteval();
       Diagnosed = true;
     }
     SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);
   } else if (Field->isAnonymousStructOrUnion()) {
     const RecordDecl *RD = Field->getType()->castAs<RecordType>()->getDecl();
     for (auto *I : RD->fields())
       // If an anonymous union contains an anonymous struct of which any member
       // is initialized, all members must be initialized.
bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
   //   ill-formed; no diagnostic required.
   // C++11 [dcl.constexpr]p3:
   //   - every constructor call and implicit conversion used in initializing the
   //     return value shall be one of those allowed in a constant expression.
   // C++11 [dcl.constexpr]p4:
   //   - every constructor involved in initializing non-static data members and
   //     base class sub-objects shall be a constexpr constructor.
   SmallVector<PartialDiagnosticAt, 8> Diags;
   if (!Expr::isPotentialConstantExpr(Dcl, Diags)) {
     Diag(Dcl->getLocation(), diag::ext_constexpr_function_never_constant_expr)
-      << isa<CXXConstructorDecl>(Dcl);
+        << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
     for (size_t I = 0, N = Diags.size(); I != N; ++I)
       Diag(Diags[I].first, Diags[I].second);
     // Don't return false here: we allow this for compatibility in
     // system headers.
   }
 
   return true;
 }
if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
     HadError = true;
   }
 
   if (First) {
     // C++2a [dcl.fct.def.default]p3:
     //   If a function is explicitly defaulted on its first declaration, it is
     //   implicitly considered to be constexpr if the implicit declaration
     //   would be.
-    MD->setConstexprKind(Constexpr ? CSK_constexpr : CSK_unspecified);
+    MD->setConstexprKind(
+        Constexpr ? (MD->isConsteval() ? CSK_consteval : CSK_constexpr)
+                  : CSK_unspecified);
 
     if (!Type->hasExceptionSpec()) {
       // C++2a [except.spec]p3:
       //   If a declaration of a function does not have a noexcept-specifier
       //   [and] is defaulted on its first declaration, [...] the exception
       //   specification is as specified below
       FunctionProtoType::ExtProtoInfo EPI = Type->getExtProtoInfo();
       EPI.ExceptionSpec.Type = EST_Unevaluated;
CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
   DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
   if (DSM.isAlreadyBeingDeclared())
     return nullptr;
 
   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                      CXXDefaultConstructor,
                                                      false);
 
   // Create the actual constructor declaration.
   CanQualType ClassType
     = Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationName Name
     = Context.DeclarationNames.getCXXConstructorName(ClassType);
   DeclarationNameInfo NameInfo(Name, ClassLoc);
   CXXConstructorDecl *DefaultCon = CXXConstructorDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, /*Type*/ QualType(),
       /*TInfo=*/nullptr, ExplicitSpecifier(),
Sema::BuildCXXConstructExpr(SourceLocation ConstructLoc, QualType DeclInitType,
   assert(declaresSameEntity(
              Constructor->getParent(),
              DeclInitType->getBaseElementTypeUnsafe()->getAsCXXRecordDecl()) &&
          "given constructor for wrong type");
   MarkFunctionReferenced(ConstructLoc, Constructor);
   if (getLangOpts().CUDA && !CheckCUDACall(ConstructLoc, Constructor))
     return ExprError();
 
-  return CXXConstructExpr::Create(
-      Context, DeclInitType, ConstructLoc, Constructor, Elidable,
-      ExprArgs, HadMultipleCandidates, IsListInitialization,
-      IsStdInitListInitialization, RequiresZeroInit,
+  ExprResult CtorExpr = CXXConstructExpr::Create(
+      Context, DeclInitType, ConstructLoc, Constructor, Elidable, ExprArgs,
+      HadMultipleCandidates, IsListInitialization, IsStdInitListInitialization,
+      RequiresZeroInit,
       static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
       ParenRange);
+
+  if (Constructor->isConsteval())
+    CtorExpr = ActOnConstevalCall(Constructor, CtorExpr.get());
+
+  return CtorExpr;
 }
 
 ExprResult Sema::BuildCXXDefaultInitExpr(SourceLocation Loc, FieldDecl *Field) {
   assert(Field->hasInClassInitializer());
 
   // If we already have the in-class initializer nothing needs to be done.
   if (Field->getInClassInitializer())
     return CXXDefaultInitExpr::Create(Context, Loc, Field, CurContext);

clang/lib/Sema/SemaExpr.cpp

 ///
 /// \returns nullptr If this builtin is not a candidate for a rewrite i.e.
 ///                  it does not contain any pointer arguments without
 ///                  an address space qualifer.  Otherwise the rewritten
 ///                  FunctionDecl is returned.
 /// TODO: Handle pointer return types.
 static FunctionDecl *rewriteBuiltinFunctionDecl(Sema *Sema, ASTContext &Context,
                                                 const FunctionDecl *FDecl,
-                                                MultiExprArg ArgExprs) {
+                                                MultiExprArg ArgExprs,
+                                                bool Diagnose = true) {
 
   QualType DeclType = FDecl->getType();
   const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(DeclType);
 
   if (!Context.BuiltinInfo.hasPtrArgsOrResult(FDecl->getBuiltinID()) ||
       !FT || FT->isVariadic() || ArgExprs.size() != FT->getNumParams())
     return nullptr;
 
   bool NeedsNewDecl = false;
   unsigned i = 0;
   SmallVector<QualType, 8> OverloadParams;
 
   for (QualType ParamType : FT->param_types()) {
 
     // Convert array arguments to pointer to simplify type lookup.
     ExprResult ArgRes =
-        Sema->DefaultFunctionArrayLvalueConversion(ArgExprs[i++]);
+        Sema->DefaultFunctionArrayLvalueConversion(ArgExprs[i++], Diagnose);
     if (ArgRes.isInvalid())
       return nullptr;
     Expr *Arg = ArgRes.get();
     QualType ArgType = Arg->getType();
     if (!ParamType->isPointerType() ||
         ParamType.getQualifiers().hasAddressSpace() ||
         !ArgType->isPointerType() ||
         !ArgType->getPointeeType().getQualifiers().hasAddressSpace()) {
if (!EnclosingFunctionCtx->isDependentContext()) {
     // ... since this is an implicit member reference, that might potentially
     // involve a 'this' capture, mark 'this' for potential capture in
     // enclosing lambdas.
     if (CurLSI->ImpCaptureStyle != CurLSI->ImpCap_None)
       CurLSI->addPotentialThisCapture(CallLoc);
   }
 }
 
+/// Traverses throught an APValue to verify there is no pointers on consteval
+/// functions.
+static bool CheckPointerOnConsteval(const APValue& Value) {
+  switch (Value.getKind()){
+    default:
+      return false;
+    case APValue::Union:
+      return CheckPointerOnConsteval(Value.getUnionValue());
+    case APValue::Struct:
+      for (unsigned I = 0; I < Value.getStructNumBases(); I++)
+        if (CheckPointerOnConsteval(Value.getStructBase(I)))
+          return true;
+      for (unsigned I = 0; I < Value.getStructNumFields(); I++)
+        if (CheckPointerOnConsteval(Value.getStructField(I)))
+          return true;
+      return false;
+    case APValue::Array:
+      for (unsigned I = 0; I < Value.getArrayInitializedElts(); I++)
+        if (CheckPointerOnConsteval(Value.getArrayInitializedElt(I)))
+          return true;
+      return false;
+    case APValue::Vector:
+      for (unsigned I = 0; I < Value.getVectorLength(); I++)
+        if (CheckPointerOnConsteval(Value.getVectorElt(I)))
+          return true;
+      return false;
+    case APValue::MemberPointer:
+      if (auto* FD = dyn_cast<FunctionDecl>(Value.getMemberPointerDecl()))
+        return FD->isConsteval();
+      return false;
+    case APValue::LValue:
+      if (Value.getLValueBase())
+        if (auto* VD = Value.getLValueBase().dyn_cast<const ValueDecl*>())
+          if (auto* FD = dyn_cast<FunctionDecl>(VD))
+            return FD->isConsteval();
+      return false;
+  }
+}
+
+ExprResult Sema::ActOnConstevalCall(FunctionDecl *FD, Expr *Call) {
+  Expr::EvalResult Result;
+  llvm::SmallVector<PartialDiagnosticAt, 8> Diags;
+  Result.Diag = &Diags;
+  Call->EvaluateAsConstantExpr(Result, Expr::EvaluateForCodeGen, Context);
+  if (!Result.Diag->empty()) {
+    Diag(Call->getBeginLoc(), diag::err_invalid_consteval_call)
+        << FD << isa<CXXConstructorDecl>(FD);
+    Diag(FD->getLocation(), diag::note_callee_decl) << FD;
+    for (auto Note : *Result.Diag)
+      Diag(Note.first, Note.second);
+    return ExprError();
+  }
+  if (CheckPointerOnConsteval(Result.Val)) {
+    Diag(Call->getBeginLoc(), diag::err_consteval_address_accessible)
+        << isa<CXXConstructorDecl>(FD);
+    return ExprError();
+  }
+  return ConstantExpr::Create(Context, Call, std::move(Result.Val));
+}
+
 ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
                                Expr *ExecConfig) {
   ExprResult Call =
       BuildCallExpr(Scope, Fn, LParenLoc, ArgExprs, RParenLoc, ExecConfig);
   if (Call.isInvalid())
     return Call;
 
   // Diagnose uses of the C++20 "ADL-only template-id call" feature in earlier
   // language modes.
   if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(Fn)) {
     if (ULE->hasExplicitTemplateArgs() &&
         ULE->decls_begin() == ULE->decls_end()) {
       Diag(Fn->getExprLoc(), getLangOpts().CPlusPlus2a
                                  ? diag::warn_cxx17_compat_adl_only_template_id
                                  : diag::ext_adl_only_template_id)
           << ULE->getName();
     }
   }
 
+  if (CallExpr *CExpr = dyn_cast<CallExpr>(Call.get()))
+    if (auto *FD = dyn_cast_or_null<FunctionDecl>(CExpr->getCalleeDecl()))
+      if (FD && FD->isConsteval() && !isConstantEvaluated())
+        Call = ActOnConstevalCall(FD, CExpr);
   return Call;
 }
 
 /// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
 /// This provides the location of the left/right parens and a list of comma
 /// locations.
 ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
   if (auto *DRE = dyn_cast<DeclRefExpr>(NakedFn)) {
     NDecl = DRE->getDecl();
 
     FunctionDecl *FDecl = dyn_cast<FunctionDecl>(NDecl);
     if (FDecl && FDecl->getBuiltinID()) {
       // Rewrite the function decl for this builtin by replacing parameters
       // with no explicit address space with the address space of the arguments
       // in ArgExprs.
-      if ((FDecl =
-               rewriteBuiltinFunctionDecl(this, Context, FDecl, ArgExprs))) {
+      if ((FDecl = rewriteBuiltinFunctionDecl(this, Context, FDecl, ArgExprs,
+                                              /*Diagnose*/ false))) {
         NDecl = FDecl;
         Fn = DeclRefExpr::Create(
             Context, FDecl->getQualifierLoc(), SourceLocation(), FDecl, false,
             SourceLocation(), FDecl->getType(), Fn->getValueKind(), FDecl,
             nullptr, DRE->isNonOdrUse());
       }
     }
   } else if (isa<MemberExpr>(NakedFn))
     NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
void Sema::WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec) {
   }
   Rec.PossibleDerefs.clear();
 }
 
 void Sema::PopExpressionEvaluationContext() {
   ExpressionEvaluationContextRecord& Rec = ExprEvalContexts.back();
   unsigned NumTypos = Rec.NumTypos;
 
   if (!Rec.Lambdas.empty()) {
     using ExpressionKind = ExpressionEvaluationContextRecord::ExpressionKind;
     if (Rec.ExprContext == ExpressionKind::EK_TemplateArgument || Rec.isUnevaluated() ||
         (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17)) {
       unsigned D;
       if (Rec.isUnevaluated()) {
         // C++11 [expr.prim.lambda]p2:
         //   A lambda-expression shall not appear in an unevaluated operand
         //   (Clause 5).
         D = diag::err_lambda_unevaluated_operand;
       } else if (Rec.isConstantEvaluated() && !getLangOpts().CPlusPlus17) {
         // C++1y [expr.const]p2:
         //   A conditional-expression e is a core constant expression unless the
         //   evaluation of e, following the rules of the abstract machine, would
         //   evaluate [...] a lambda-expression.
         D = diag::err_lambda_in_constant_expression;
void Sema::PopExpressionEvaluationContext() {
   }
 
   WarnOnPendingNoDerefs(Rec);
 
   // When are coming out of an unevaluated context, clear out any
   // temporaries that we may have created as part of the evaluation of
   // the expression in that context: they aren't relevant because they
   // will never be constructed.
   if (Rec.isUnevaluated() || Rec.isConstantEvaluated()) {
     ExprCleanupObjects.erase(ExprCleanupObjects.begin() + Rec.NumCleanupObjects,
                              ExprCleanupObjects.end());
     Cleanup = Rec.ParentCleanup;
     CleanupVarDeclMarking();
     std::swap(MaybeODRUseExprs, Rec.SavedMaybeODRUseExprs);
   // Otherwise, merge the contexts together.
   } else {
     Cleanup.mergeFrom(Rec.ParentCleanup);
     MaybeODRUseExprs.insert(Rec.SavedMaybeODRUseExprs.begin(),
                             Rec.SavedMaybeODRUseExprs.end());
   }
 
   // Pop the current expression evaluation context off the stack.
   ExprEvalContexts.pop_back();
 

 ExprResult Sema::HandleExprEvaluationContextForTypeof(Expr *E) {
   ExprResult Result = CheckPlaceholderExpr(E);
   if (Result.isInvalid())
     return ExprError();
   E = Result.get();
   if (!E->getType()->isVariablyModifiedType())
     return E;
   return TransformToPotentiallyEvaluated(E);
 }
 
 /// Are we in a context that is potentially constant evaluated per C++20
 /// [expr.const]p12?
 static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef) {
   /// C++2a [expr.const]p12:
   //   An expression or conversion is potentially constant evaluated if it is
   switch (SemaRef.ExprEvalContexts.back().Context) {
     case Sema::ExpressionEvaluationContext::ConstantEvaluated:
       // -- a manifestly constant-evaluated expression,
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
     case Sema::ExpressionEvaluationContext::DiscardedStatement:
       // -- a potentially-evaluated expression,
     case Sema::ExpressionEvaluationContext::UnevaluatedList:
       // -- an immediate subexpression of a braced-init-list,
 
       // -- [FIXME] an expression of the form & cast-expression that occurs
       //    within a templated entity
       // -- a subexpression of one of the above that is not a subexpression of
       // a nested unevaluated operand.
       return true;
 
     case Sema::ExpressionEvaluationContext::Unevaluated:
     case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
       // Expressions in this context are never evaluated.
       return false;
   }
   llvm_unreachable("Invalid context");

clang/lib/Sema/SemaLambda.cpp

void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
   LSI->ContainsUnexpandedParameterPack = ContainsUnexpandedParameterPack;
 
   // Add lambda parameters into scope.
   addLambdaParameters(Intro.Captures, Method, CurScope);
 
   // Enter a new evaluation context to insulate the lambda from any
   // cleanups from the enclosing full-expression.
   PushExpressionEvaluationContext(
-      ExpressionEvaluationContext::PotentiallyEvaluated);
+      LSI->CallOperator->isConsteval()
+          ? ExpressionEvaluationContext::ConstantEvaluated
+          : ExpressionEvaluationContext::PotentiallyEvaluated);
 }
 
 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
                             bool IsInstantiation) {
   LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back());
 
   // Leave the expression-evaluation context.
   DiscardCleanupsInEvaluationContext();

clang/lib/Sema/SemaOverload.cpp

 /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
 ///   we in overload resolution?
 /// \param Loc - The location of the statement we're complaining about. Ignored
 ///   if we're not complaining, or if we're in overload resolution.
 static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
                                               bool Complain,
                                               bool InOverloadResolution,
                                               SourceLocation Loc) {
+  if (!S.isConstantEvaluated() && FD->isConsteval()) {
+    if (Complain) {
+      if (InOverloadResolution)
+        S.Diag(FD->getBeginLoc(), diag::note_addrof_ovl_consteval);
+      else {
+        S.Diag(Loc, diag::err_invalid_consteval_take_address) << FD;
+        S.Diag(FD->getBeginLoc(), diag::note_declared_at);
+      }
+    }
+    return false;
+  }
+
   if (!isFunctionAlwaysEnabled(S.Context, FD)) {
     if (Complain) {
       if (InOverloadResolution)
         S.Diag(FD->getBeginLoc(),
                diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
       else
         S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
     }

clang/test/SemaCXX/cxx2a-consteval.cpp

struct D {
   C c;
   consteval D() = default; // expected-error {{cannot be consteval}}
 };
 }
 
 consteval int main() { // expected-error {{'main' is not allowed to be declared consteval}}
   return 0;
 }
+
+int i_runtime; // expected-note+ {{declared here}}
+constexpr int i_constexpr = 0;
+
+consteval int f_eval(int i) {
+// expected-note@-1+ {{declared here}}
+  return i;
+}
+
+constexpr auto l_eval = [](int i) consteval {
+// expected-note@-1+ {{declared here}}
+  return i;
+};
+
+struct A {
+  int I = 0;
+  consteval int f_eval(int i) const {
+// expected-note@-1+ {{declared here}}
+    return I + i;
+// expected-note@-1 {{is not allowed in a constant expression}}
+  }
+};
+
+constexpr A a;
+
+namespace invalid_call {
+
+int d2 = f_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+int l2 = l_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+int m2 = a.f_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+int d4 = f_eval(i_constexpr);
+int l4 = l_eval(i_constexpr);
+int m4 = a.f_eval(i_constexpr);
+
+constexpr int f1(int i) { // expected-note+ {{declared here}}
+  int d0 = f_eval(0);
+  int l0 = l_eval(0);
+  int m0 = a.f_eval(0);
+  int d2 = f_eval(i);
+  // expected-error@-1 {{could not be evaluated}}
+  // expected-error@-2 {{must be initialized}}
+  // FIXME: the error above should not appear when the initializer present but is invalid.
+  // expected-note@-4 {{is not allowed in a constant expression}}
+
+  int l2 = l_eval(i);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+  int m2 = a.f_eval(i);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+  int d6 = f_eval(i_constexpr);
+  int l6 = l_eval(i_constexpr);
+  int m6 = a.f_eval(i_constexpr);
+  int d8 = f_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+  int l8 = l_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+  int m8 = a.f_eval(i_runtime);
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{is not allowed in a constant expression}}
+  return 0;
+}
+
+consteval int f2(int i) {
+// expected-error@-1 {{never produces a constant expression}}
+  int d0 = f_eval(i);
+  int l0 = l_eval(i);
+  int m0 = a.f_eval(i);
+  int d1 = f_eval(i_runtime);
+// expected-note@-1 {{is not allowed in a constant expression}}
+  int l1 = l_eval(i_runtime);
+  int m1 = a.f_eval(i_runtime);
+  return 0;
+}
+
+void test() {
+  A a_dependent;
+  // expected-note@-1+ {{declared here}}
+
+  int Int = 0;
+  auto l_dependent = [Int](int i) consteval {
+    // expected-note@-1+ {{declared here}}
+    return Int + i;
+    // expected-note@-1 {{is not allowed in a constant expression}}
+  };
+
+  int i_l = l_dependent(0);
+  // expected-error@-1 {{could not be evaluated}}
+  // expected-note@-2 {{in call}}
+
+  int i_m = a_dependent.f_eval(0);
+  // expected-error@-1 {{could not be evaluated}}
+  // expected-note@-2 {{in call}}
+}
+
+}
+
+namespace taking_address {
+
+using func_type = int(int);
+using mem_ptr_type = int(A::*)(int);
+
+func_type* p1 = (&f_eval);
+// expected-error@-1 {{take address}}
+func_type* p2= &(((f_eval)));
+// expected-error@-1 {{take address}}
+func_type* p3 = (func_type*)f_eval;
+// expected-error@-1 {{take address}}
+func_type* p4 = static_cast<func_type*>(f_eval);
+// expected-error@-1 {{take address}}
+func_type* p5 = reinterpret_cast<func_type*>(f_eval);
+// expected-error@-1 {{take address}}
+func_type* p6 = reinterpret_cast<func_type*>(&reinterpret_cast<char>(f_eval));
+// expected-error@-1 {{take address}}
+func_type* p7 = __builtin_addressof(f_eval);
+// expected-error@-1 {{take address}}
+
+auto p = f_eval;
+// expected-error@-1 {{take address}}
+
+mem_ptr_type m1 = &A::f_eval;
+// expected-error@-1 {{take address}}
+auto* l1 = &decltype(l_eval)::operator();
+// expected-error@-1 {{take address}}
+
+consteval int f(int i) {
+// expected-note@-1+ {{declared here}}
+  return i;
+}
+
+auto ptr = &f;
+// expected-error@-1 {{take address}}
+
+auto f1() {
+  return &f;
+// expected-error@-1 {{take address}}
+}
+
+constexpr auto f2() {
+  return &f;
+// expected-error@-1 {{take address}}
+}
+
+consteval auto f3() {
+  return &f;
+}
+
+consteval int Overload() {
+//expected-note@-1 {{candidate function made ineligible by consteval specifier}}
+  return 0;
+}
+
+int Overload(int i) {
+//expected-note@-1 {{candidate function}}
+  return i;
+}
+
+auto Ptr = &Overload;
+int(*Ptr1)() = &Overload;
+// expected-error@-1 {{does not match}}
+int(*Ptr2)(int) = &Overload;
+
+}
+
+namespace misc {
+
+consteval int f(int i) {
+  return i;
+}
+
+using func_type = int(int);
+
+consteval func_type* f1() {
+  return &f;
+}
+
+int run(int i) {
+  return f1()(i);
+// expected-error@-1 {{contain pointer on consteval declaration}}
+}
+
+struct A {
+  mutable func_type *tmp = nullptr;
+  consteval int f1() const {
+// expected-note@-1 {{declared here}}
+    tmp = &f;
+// expected-note@-1 {{cannot modify}}
+    return 0;
+  }
+};
+
+constexpr A a;
+
+int v(int i) {
+  a.f1();
+// expected-error@-1 {{could not be evaluated}}
+// expected-note@-2 {{in call}}
+  return a.tmp(i);
+}
+
+struct B {
+  func_type *tmp = nullptr;
+  consteval B() {
+    tmp = &f;
+  }
+};
+
+int v2(int i) {
+  constexpr B b;
+// expected-error@-1 {{contain pointer on consteval declaration}}
+  return b.tmp(i);
+}
+
+}
+
+namespace invalid_function {
+using size_t = unsigned long;
+struct A {
+  consteval void *operator new(size_t count);
+  // expected-error@-1 {{operator new cannot be consteval}}
+  consteval void *operator new[](size_t count);
+  // expected-error@-1 {{operator new[] cannot be consteval}}
+  consteval void operator delete(void* ptr);
+  // expected-error@-1 {{operator delete cannot be consteval}}
+  consteval void operator delete[](void* ptr);
+  // expected-error@-1 {{operator delete[] cannot be consteval}}
+  consteval ~A();
+  // expected-error@-1 {{destructor cannot be marked consteval}}
+};
+
+}
+
+namespace Ctor {
+
+struct A {
+  int i;
+  float f;
+  consteval A(int i, float f) : i(i), f(f) {}
+  //expected-note@-1 {{declared here}}
+  consteval A(const A&) = default;
+  //expected-note@-1 {{declared here}}
+  consteval A(A&&) = default;
+  //expected-note@-1 {{declared here}}
+};
+
+void test(int i) {
+  //expected-note@-1 {{declared here}}
+  A a(i, 0);
+  //expected-error@-1 {{could not be evaluated}}
+  //expected-note@-2 {{is not allowed in a constant expression}}
+  A a1(0, 1);
+  //expected-note@-1+ {{declared here}}
+  A a3(a1);
+  //expected-error@-1 {{could not be evaluated}}
+  //expected-note@-2 {{is not allowed in a constant expression}}
+  //expected-note@-3 {{in call}}
+  A a4(static_cast<A&&>(a1));
+  //expected-error@-1 {{could not be evaluated}}
+  //expected-note@-2 {{is not allowed in a constant expression}}
+  //expected-note@-3 {{in call}}
+  constexpr A a5(0, 4);
+  A a6(a5);
+}
+
+}
 No newline at end of file