[C++20] add Basic consteval specifier

[Tyker]

Summary

this revision adds Lexing, Parsing and Basic Semantic for the consteval specifier as specified by http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1073r3.html

with this patch, the consteval specifier is treated as constexpr but can only be applied to function declaration.

Changes:

• add the consteval keyword.
• add parsing of consteval specifier for normal declarations and lambdas expressions.
• add the whether a declaration is constexpr is now represented by and enum everywhere except for variable because they can't be consteval.
• adapt diagnostic about constexpr to print constexpr or consteval depending on the case.
• add tests for basic semantic.

[martong]

ASTImporter.cpp looks good to me.

[Tyker]

code-gen was adapted to consteval.

i have a question. what C++ code generate a complex value in llvm's representation ?

[efriedma]

"complex" in this context is the C99 _Complex, which is supported in C++ as an extension, using the same syntax as C. You can just declare a variable with type _Complex float. If you need to manipulate the real and imaginary parts of a variable, you can use the gcc extension __real__/__imag__, although I don't think you need to.

[rsmith]

Thanks for working on this!

Comments on the general approach:

• We should only evaluate each immediate invocation once (this will become essential once we start supporting reflection -- and particularly operations that mutate the AST -- inside consteval functions).
• Each time an immediate invocation is formed, you should create a ConstantExpr AST node wrapping that call to reflect that it is a constant.
• You should change ConstantExpr to store an APValue representing the evaluated value of the expression.

Most of the above should be done as a separate preparatory change; we should be able to remove a lot of the existing ad-hoc caching of evaluated values (eg, for enumerators and the initializers of variables) at the same time.

Please also split this into smaller pieces. If you split off a patch to just add the keyword, parsing, and AST representation for the consteval specifier (but treat it identically to constexpr for constant evaluation purposes), that'd be a good first patch for this feature.

clang/include/clang/AST/Decl.h

2102

Please rename this to isConstexprSpecified() (compare this to how we model inline, which has similar behavior: it can be explicit, or can be implied by other properties of the function).

2109

Both the constexpr and consteval specifiers make a function a "constexpr function", so I think this should be called simply isConstexpr; callers that want to distinguish constexpr from consteval can use isConsteval() (or we can add a getConstexprKind() or similar function).

clang/include/clang/AST/DeclCXX.h

2115

Instead of the three bool flags in a row here (which will make call sites hard to read), consider using an enum, perhaps:

enum class ConstexprSpecifierKind { None, Constexpr, Consteval };

clang/include/clang/Basic/DiagnosticSemaKinds.td

2297–2300

It would be useful in these diagnostics to explain why the call is required to be constant evaluated; please also use the standard terminology "constant expression" here. (Eg, "call to consteval function %0 is not a constant expression")

2308–2314

In these diagnostics (including the existing one for tags), we should say "declared constexpr" not "marked constexpr".

clang/include/clang/Basic/TokenKinds.def

390–391

This and char8_t are both adopted C++2a features now (they'e not just proposals any more); please change the comment to just "C++2a keywords".

clang/include/clang/Sema/DeclSpec.h

404

I think it would be preferable to track only one location here (for the constexpr / consteval specifier) and store a constexpr specifier kind instead of Constexpr_specified, like we do for the other kinds of specifier for which we allow only one of a set of keywords.

clang/include/clang/Sema/Sema.h

985–986

An "immediate function context" is also "potentially evaluated"; I think what we want to say here is something like "The current context is "potentially evaluated", but will only ever be constant evaluated; runtime code will never be generated for it. (Eg, the case values of a switch, or the body of a consteval function.)"

4052–4053

Please don't use the "FunctionName - " style in new code.

4054

return -> \return

4055–4056

Drop the "Invalid" from this function name; it doesn't add anything. But I think this is the wrong interface anyway -- I'll get to that later.

clang/lib/AST/ExprConstant.cpp

4474–4475

We should not need to do this; instead, when the evaluator hits a ConstantExpr node, it should use the already-evaluated value of that node.

clang/lib/Parse/ParseDecl.cpp

2480–2487

Do not pass random English words into diagnostics; this makes translation impossible. Use a %select or two different diagnostics instead. (Passing in C++ syntax such as constexpr or consteval is OK, since they don't need to be translated.)

clang/lib/Parse/ParseExprCXX.cpp

1073–1075

It doesn't seem worthwhile to me to support consteval in earlier language modes only for lambdas; if we really want to allow consteval as an extension in earlier language modes, the better approach would be to add a __consteval keyword. But regardless of whether we do that, please remove this.

1303–1305

Please follow the formatting of the adjacent code.

clang/lib/Sema/DeclSpec.cpp

1326–1332

This should be handled by SetConstevalSpec instead; please look for calls to BadSpecifier to see how we handle this for other kinds of specifier.

clang/lib/Sema/SemaChecking.cpp

10471 ↗

(On Diff #199428)

Are the changes to this file really specific to consteval evaluation? They look more general than that; I think this would fix the evaluation of std::is_constant_evaluated() in any constant-evaluated context that we analyzed. Can this be split out of this patch into a separate change?

clang/lib/Sema/SemaDeclCXX.cpp

640–648

This will produce diagnostics such as "non-constexpr declaration follows constexpr declaration" for a consteval declaration following a constexpr declaration, which seems misleading since a consteval declaration does declare a constexpr function. I think the order of these two checks should be reversed, so that that case will instead be diagnosed as "consteval declaration follows non-consteval declaration".

6655

The diagnostic text here is:

error: defaulted definition of <thing> is not constexpr

which might be confusing if the user wrote consteval thing = default;. Maybe change the diagnostic to:

"defaulted definition of <thing> cannot be declared %select{constexpr|consteval}1 because its implicit definition would not be constexpr"

or something like that?

clang/lib/Sema/SemaExpr.cpp

5720–5769

This checking doesn't make sense: we should be checking that the invocation as a whole is a constant expression, not whether the arguments (evaluated in isolation) are constant expressions. This check should be applied to the Expr representing the call, and should wrap it in a ConstantExpr holding the evaluated value if evaluation succeeds.

13417–13435

This isn't correct: you can take the address of a consteval function within an immediate invocation. In general, we need to delay this checking until we've finished processing any potentially-enclosing immediate invocations. Trying to capture all of the places where we might form a reference to a consteval function name without forming an immediate invocation is also fragile: you'll miss some, and as Clang is extended, there'll be more cases introduced that you miss.

Here's how I was intending to handle this:

• Change Sema::MarkFunctionReferenced to take an Expr* instead of a location, and update all of its callers. (We'll need a separate function for marking destructors referenced, because destructor calls typically don't have expressions, but destructors can't be consteval so that's OK.)
• In Sema::MarkFunctionReferenced, if Func is a consteval function and our current context is not a consteval function, add it to a list on the ExpressionEvaluationContext.
• When forming an immediate invocation, walk all of its subexpressions and remove them all from the list on the ExpressionEvaluationContext
• When popping the ExpressionEvaluationContext, diagnose any remaining expressions in its list.

(The first step should be done in a separate patch to keep the diffs smaller and easier to review.)

[Tyker]

previous revision was spitted in multiple part as requested
consteval specific semantic and code-gen have been removed from the patch.
other parts:

• fixing semantic checking in constant context : https://reviews.llvm.org/D62009
• adding storage for APValue in ConstantExpr : https://reviews.llvm.org/D62399

some remarks weren't fixed because the changes are not present in this patch.

[Tyker]

clang/lib/Sema/SemaChecking.cpp

10471 ↗

(On Diff #199428)

this can be splited in and other patch. https://reviews.llvm.org/D62009.

clang/lib/Sema/SemaExpr.cpp

5720–5769

the idea behind this check was "if the function satisfies the rules of constexpr and all it arguments can be constant evaluated. this function call can be constant evaluated". this was a easy way of checking that the call could be evaluated without evaluating it.

this will be added in later patch after https://reviews.llvm.org/D62399.

13417–13435

delayed to later patch.

[Tyker]

@rsmith ping

[rsmith]

Thank you!

clang/include/clang/AST/DeclBase.h

1495

"kind" -> "Kind"
"Contexpr" -> "constexpr"

clang/lib/AST/DeclPrinter.cpp

615

The only way a defaulted function can be consteval is if consteval was literally written on the declaration, so I think we should print out the consteval keyword for all consteval functions regardless of whether they're defaulted.

clang/lib/Parse/ParseDecl.cpp

2490–2491

Should this say which specifier was used? Or do we somehow reject eg. sizeof(consteval int) before we get here?

clang/lib/Parse/ParseExprCXX.cpp

1097–1099

We should produce a -Wc++17-compat diagnostic similar to this for uses of consteval.

clang/lib/Sema/DeclSpec.cpp

1295–1296

For consteval we should produce an "incompatible with C++ standards before C++2a" diagnostic, not an "incompatible with C++98" diagnostic.

clang/lib/Sema/SemaDecl.cpp

4300

Please capitalize this variable name.

6660

Please consider renaming this diagnostic; err_constexpr_no_declarators doesn't describe the problem here. Maybe err_constexpr_wrong_decl_kind or something?

clang/lib/Sema/SemaDeclCXX.cpp

6655

I don't think the change here has really addressed the problem. We now say:

error: defaulted definition of <thing> is not consteval

in this case, which doesn't explain what's wrong, and appears to directly contradict what the user wrote. The problem is that the implicit definition would not be constexpr, so we should say that.

[Tyker]

fixed requested changes except some i commented upon.

clang/lib/Parse/ParseDecl.cpp

2490–2491

sizeof(consteval int) was rejected before this point but the diagnostics was bad. so i improved it.

clang/lib/Parse/ParseExprCXX.cpp

1097–1099

a consteval keyword can only be lexed when we are in C++2a because it is a C++2a keyword so the warning would never fire.

clang/lib/Sema/DeclSpec.cpp

1295–1296

same as previous comment. the consteval keyword cannot be lexed unless we are in c++2a mode so the warning would never fire.

[rsmith]

Only minor comments remain (other than the -Wc++17-compat warning). In the interest of incremental progress, let's leave the -Wc++17-compat warning for a later patch; feel free to commit this after fixing up the other things.

(If you don't have commit access yet, now would be a good time to request it; please read http://llvm.org/docs/DeveloperPolicy.html for details.)

Thanks again!

clang/include/clang/Basic/DiagnosticSemaKinds.td

1583

Should this say consteval rather than virtual?

Actually... looks like this new diagnostic is not used, and could just be removed?

7828

Remove stray "be" here.

clang/lib/AST/ExprConstant.cpp

4385–4386

The Definition && [...] Definition->isInvalidDecl() case was handled a few lines above; this change appears to have no effect.

clang/lib/Parse/ParseExprCXX.cpp

1097–1099

The purpose of this warning is to warn about code parsed in C++2a mode that would not be valid in C++17. Try (eg) enabling -Wc++98-compat and building some C++11 code to see what's supposed to happen.

clang/lib/Sema/DeclSpec.cpp

1295–1296

(See previous reply.)

[Tyker]

fixed requested changes.
also adapted lldb to AST change.
I will commit this when i have access.

[dyung]

Hi, the test cxx2a-consteval.cpp that you added in this commit is failing on the PS4 Windows bot.

http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/9/steps/test/logs/stdio

FAIL: Clang :: SemaCXX/cxx2a-consteval.cpp (13131 of 50204)
******************** TEST 'Clang :: SemaCXX/cxx2a-consteval.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.obj\bin\clang.exe -cc1 -internal-isystem c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.obj\lib\clang\9.0.0\include -nostdsysteminc -std=c++2a -fsyntax-only C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp -verify
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.obj\bin\clang.exe" "-cc1" "-internal-isystem" "c:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.obj\lib\clang\9.0.0\include" "-nostdsysteminc" "-std=c++2a" "-fsyntax-only" "C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp" "-verify"
# command stderr:
error: 'error' diagnostics expected but not seen: 

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 9 (directive at C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp:10): cannot combine

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 30: destructor cannot be marked consteval

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 33: struct cannot be marked consteval

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 35: typedef cannot be consteval

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 40: consteval can only be used in function declarations

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 42: consteval can only be used in function declarations

error: 'error' diagnostics seen but not expected: 

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 30: destructor cannot be marked constexpr

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 33: struct cannot be marked constexpr

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 35: typedef cannot be constexpr

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 42: constexpr can only be used in variable and function declarations

error: 'warning' diagnostics seen but not expected: 

  File C:\ps4-buildslave2\llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast\llvm.src\tools\clang\test\SemaCXX\cxx2a-consteval.cpp Line 9: duplicate 'constexpr' declaration specifier

11 errors generated.


error: command failed with exit status: 1

Can you take a look?

[rnk]

cfe/trunk/include/clang/Sema/DeclSpec.h

366 ↗

(On Diff #204723)

Please always use unsigned for bitfields to avoid sign extensions under MSVC. I've fixed this in r363450. This makes the test you added pass on Windows (@dyung's comment).

clang/include/clang/AST/Decl.h

private:
 
   /// State that an ODRHash has been stored.
   void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }
 
 protected:
   FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                const DeclarationNameInfo &NameInfo, QualType T,
                TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
-               bool isConstexprSpecified);
+               bool isConstexprSpecified, bool isConstevalSpecified);
 
   using redeclarable_base = Redeclarable<FunctionDecl>;
 
   FunctionDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
   }
 
   FunctionDecl *getPreviousDeclImpl() override {
public:
 
   using redeclarable_base::redecls_begin;
   using redeclarable_base::redecls_end;
   using redeclarable_base::redecls;
   using redeclarable_base::getPreviousDecl;
   using redeclarable_base::getMostRecentDecl;
   using redeclarable_base::isFirstDecl;
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc, SourceLocation NLoc,
-                              DeclarationName N, QualType T,
-                              TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified = false,
-                              bool hasWrittenPrototype = true,
-                              bool isConstexprSpecified = false) {
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         SourceLocation NLoc, DeclarationName N, QualType T,
+         TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified = false,
+         bool hasWrittenPrototype = true, bool isConstexprSpecified = false,
+         bool isConstevalSpecified = false) {
     DeclarationNameInfo NameInfo(N, NLoc);
-    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
-                                SC,
+    return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
                                 isInlineSpecified, hasWrittenPrototype,
-                                isConstexprSpecified);
+                                isConstexprSpecified, isConstevalSpecified);
   }
 
-  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
-                              SourceLocation StartLoc,
-                              const DeclarationNameInfo &NameInfo,
-                              QualType T, TypeSourceInfo *TInfo,
-                              StorageClass SC,
-                              bool isInlineSpecified,
-                              bool hasWrittenPrototype,
-                              bool isConstexprSpecified = false);
+  static FunctionDecl *
+  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+         const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
+         StorageClass SC, bool isInlineSpecified, bool hasWrittenPrototype,
+         bool isConstexprSpecified = false, bool isConstevalSpecified = false);
 
   static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   DeclarationNameInfo getNameInfo() const {
     return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
   }
 
   void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
public:
 
   /// State that this function inherited its prototype from a
   /// previous declaration.
   void setHasInheritedPrototype(bool P = true) {
     FunctionDeclBits.HasInheritedPrototype = P;
   }
 
   /// Whether this is a (C++11) constexpr function or constexpr constructor.
   bool isConstexpr() const { return FunctionDeclBits.IsConstexpr; }
   void setConstexpr(bool IC) { FunctionDeclBits.IsConstexpr = IC; }
 
+  /// Whether this is a (C++2a) consteval function or consteval constructor.
+  bool isConsteval() const { return FunctionDeclBits.IsConsteval; }
+  void setConsteval(bool IC) { FunctionDeclBits.IsConsteval = IC; }
+
+  bool isConstexprOrConsteval() const { return isConstexpr() || isConsteval(); }
+
   /// Whether the instantiation of this function is pending.
   /// This bit is set when the decision to instantiate this function is made
   /// and unset if and when the function body is created. That leaves out
   /// cases where instantiation did not happen because the template definition
   /// was not seen in this TU. This bit remains set in those cases, under the
   /// assumption that the instantiation will happen in some other TU.
   bool instantiationIsPending() const {
     return FunctionDeclBits.InstantiationIsPending;

clang/include/clang/AST/DeclBase.h

class FunctionDeclBitfields {
 
     /// Used by CXXMethodDecl
     uint64_t IsDefaulted : 1;
     /// Used by CXXMethodDecl
     uint64_t IsExplicitlyDefaulted : 1;
     uint64_t HasImplicitReturnZero : 1;
     uint64_t IsLateTemplateParsed : 1;
     uint64_t IsConstexpr : 1;
+    uint64_t IsConsteval : 1;
     uint64_t InstantiationIsPending : 1;
 
     /// Indicates if the function uses __try.
     uint64_t UsesSEHTry : 1;
 
     /// Indicates if the function was a definition
     /// but its body was skipped.
     uint64_t HasSkippedBody : 1;
class FunctionDeclBitfields {
     /// deduction candidate' (is used during overload resolution).
     uint64_t IsCopyDeductionCandidate : 1;
 
     /// Store the ODRHash after first calculation.
     uint64_t HasODRHash : 1;
   };
 
   /// Number of non-inherited bits in FunctionDeclBitfields.
-  enum { NumFunctionDeclBits = 24 };
+  enum { NumFunctionDeclBits = 25 };
 
   /// Stores the bits used by CXXConstructorDecl. If modified
   /// NumCXXConstructorDeclBits and the accessor
   /// methods in CXXConstructorDecl should be updated appropriately.
   class CXXConstructorDeclBitfields {
     friend class CXXConstructorDecl;
     /// For the bits in DeclContextBitfields.
     uint64_t : NumDeclContextBits;
     /// For the bits in FunctionDeclBitfields.
     uint64_t : NumFunctionDeclBits;
 
     /// 24 bits to fit in the remaining available space.
     /// Note that this makes CXXConstructorDeclBitfields take
     /// exactly 64 bits and thus the width of NumCtorInitializers
     /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
     /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
-    uint64_t NumCtorInitializers : 24;
+    uint64_t NumCtorInitializers : 23;
     uint64_t IsInheritingConstructor : 1;
 
     /// Whether this constructor has a trail-allocated explicit specifier.
     uint64_t HasTrailingExplicitSpecifier : 1;
     /// If this constructor does't have a trail-allocated explicit specifier.
     /// Whether this constructor is explicit specified.
     uint64_t IsSimpleExplicit : 1;
   };

clang/include/clang/AST/DeclCXX.h

class CXXDeductionGuideDecl : public FunctionDecl {
   void anchor() override;
 
 private:
   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
                         ExplicitSpecifier ES,
                         const DeclarationNameInfo &NameInfo, QualType T,
                         TypeSourceInfo *TInfo, SourceLocation EndLocation)
       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
-                     SC_None, false, false),
+                     SC_None, false, false, false),
         ExplicitSpec(ES) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
     setIsCopyDeductionCandidate(false);
   }
 
   ExplicitSpecifier ExplicitSpec;
   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }

 /// In the terminology of the C++ Standard, these are the (static and
 /// non-static) member functions, whether virtual or not.
 class CXXMethodDecl : public FunctionDecl {
   void anchor() override;
 
 protected:
   CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD,
                 SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
-                QualType T, TypeSourceInfo *TInfo,
-                StorageClass SC, bool isInline,
-                bool isConstexpr, SourceLocation EndLocation)
-    : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo,
-                   SC, isInline, isConstexpr) {
+                QualType T, TypeSourceInfo *TInfo, StorageClass SC,
+                bool isInline, bool isConstexpr, bool isConsteval,
+                SourceLocation EndLocation)
+      : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo, SC, isInline,
+                     isConstexpr, isConsteval) {
     if (EndLocation.isValid())
       setRangeEnd(EndLocation);
   }
 
 public:
   static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                SourceLocation StartLoc,
-                               const DeclarationNameInfo &NameInfo,
-                               QualType T, TypeSourceInfo *TInfo,
-                               StorageClass SC,
-                               bool isInline,
-                               bool isConstexpr,
-                               SourceLocation EndLocation);
+                               const DeclarationNameInfo &NameInfo, QualType T,
+                               TypeSourceInfo *TInfo, StorageClass SC,
+                               bool isInline, bool isConstexpr,
+                               bool isConsteval, SourceLocation EndLocation);
 
   static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   bool isStatic() const;
   bool isInstance() const { return !isStatic(); }
 
   /// Returns true if the given operator is implicitly static in a record
   /// context.
class CXXConstructorDecl final
   /// \{
   /// The arguments used to initialize the base or member.
   LazyCXXCtorInitializersPtr CtorInitializers;
 
   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                      const DeclarationNameInfo &NameInfo, QualType T,
                      TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline,
                      bool isImplicitlyDeclared, bool isConstexpr,
-                     InheritedConstructor Inherited);
+                     bool isConsteval, InheritedConstructor Inherited);
 
   void anchor() override;
 
   size_t numTrailingObjects(OverloadToken<InheritedConstructor>) const {
     return CXXConstructorDeclBits.IsInheritingConstructor;
   }
   size_t numTrailingObjects(OverloadToken<ExplicitSpecifier>) const {
     return CXXConstructorDeclBits.HasTrailingExplicitSpecifier;
public:
   friend TrailingObjects;
 
   static CXXConstructorDecl *CreateDeserialized(ASTContext &C, unsigned ID,
                                                 uint64_t AllocKind);
   static CXXConstructorDecl *
   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
-         bool isConstexpr,
+         bool isConstexpr, bool isConsteval,
          InheritedConstructor Inherited = InheritedConstructor());
 
   ExplicitSpecifier getExplicitSpecifier() {
     return getExplicitSpecifierInternal();
   }
   const ExplicitSpecifier getExplicitSpecifier() const {
     return getExplicitSpecifierInternal();
   }
class CXXDestructorDecl : public CXXMethodDecl {
   friend class ASTDeclWriter;
 
   // FIXME: Don't allocate storage for these except in the first declaration
   // of a virtual destructor.
   FunctionDecl *OperatorDelete = nullptr;
   Expr *OperatorDeleteThisArg = nullptr;
 
   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
-                    const DeclarationNameInfo &NameInfo,
-                    QualType T, TypeSourceInfo *TInfo,
-                    bool isInline, bool isImplicitlyDeclared)
+                    const DeclarationNameInfo &NameInfo, QualType T,
+                    TypeSourceInfo *TInfo, bool isInline,
+                    bool isImplicitlyDeclared)
       : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, /*isConstexpr=*/false, SourceLocation())
-  {
+                      SC_None, isInline, /*isConstexpr=*/false,
+                      /*isConsteval=*/false, SourceLocation()) {
     setImplicit(isImplicitlyDeclared);
   }
 
   void anchor() override;
 
 public:
   static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
                                    SourceLocation StartLoc,

 /// public:
 ///   operator bool();
 /// };
 /// \endcode
 class CXXConversionDecl : public CXXMethodDecl {
   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
                     const DeclarationNameInfo &NameInfo, QualType T,
                     TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES,
-                    bool isConstexpr, SourceLocation EndLocation)
+                    bool isConstexpr, bool isConsteval,
+                    SourceLocation EndLocation)
       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
-                      SC_None, isInline, isConstexpr, EndLocation),
+                      SC_None, isInline, isConstexpr, isConsteval, EndLocation),
         ExplicitSpec(ES) {}
   void anchor() override;
 
   ExplicitSpecifier ExplicitSpec;
 
   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
 
 public:
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 
   static CXXConversionDecl *
   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
          bool isInline, ExplicitSpecifier ES, bool isConstexpr,
-         SourceLocation EndLocation);
+         bool isConsteval, SourceLocation EndLocation);
   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
 
   ExplicitSpecifier getExplicitSpecifier() {
     return getCanonicalDecl()->ExplicitSpec;
   }
 
   const ExplicitSpecifier getExplicitSpecifier() const {
     return getCanonicalDecl()->ExplicitSpec;

clang/include/clang/Basic/DiagnosticParseKinds.td

def ext_warn_gnu_final : ExtWarn<
   "__final is a GNU extension, consider using C++11 final">,
   InGroup<GccCompat>;
 
 // Declarations.
 def err_typename_requires_specqual : Error<
   "type name requires a specifier or qualifier">;
 def err_typename_invalid_storageclass : Error<
   "type name does not allow storage class to be specified">;
-def err_typename_invalid_functionspec : Error<
-  "type name does not allow function specifier to be specified">;
-def err_typename_invalid_constexpr : Error<
-  "type name does not allow constexpr specifier to be specified">;
+def err_typename_invalid_specifier : Error<
+  "type name does not allow %0 specifier to be specified">;
 def err_typename_identifiers_only : Error<
   "typename is allowed for identifiers only">;
 
 def err_friend_invalid_in_context : Error<
   "'friend' used outside of class">;
 def err_templated_using_directive_declaration : Error<
   "cannot template a using %select{directive|declaration}0">;
 def err_unexpected_colon_in_nested_name_spec : Error<

 def err_expected_capture : Error<
   "expected variable name or 'this' in lambda capture list">;
 def err_expected_lambda_body : Error<"expected body of lambda expression">;
 def warn_cxx98_compat_lambda : Warning<
   "lambda expressions are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_lambda_missing_parens : Error<
   "lambda requires '()' before %select{'mutable'|return type|"
-  "attribute specifier|'constexpr'}0">;
+  "attribute specifier|'constexpr'|'consteval'}0">;
 def err_lambda_decl_specifier_repeated : Error<
-  "%select{'mutable'|'constexpr'}0 cannot appear multiple times in a lambda declarator">;
+  "%select{'mutable'|'constexpr'|'consteval'}0 cannot appear multiple times in a lambda declarator">;
 // C++17 lambda expressions
 def err_expected_star_this_capture : Error<
   "expected 'this' following '*' in lambda capture list">;
 
 // C++17 constexpr lambda expressions
 def warn_cxx14_compat_constexpr_on_lambda : Warning<
   "constexpr on lambda expressions is incompatible with C++ standards before C++17">,
   InGroup<CXXPre17Compat>, DefaultIgnore;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_static_main : Error<"'main' is not allowed to be declared static">;
 def err_inline_main : Error<"'main' is not allowed to be declared inline">;
 def ext_variadic_main : ExtWarn<
   "'main' is not allowed to be declared variadic">, InGroup<Main>;
 def ext_noreturn_main : ExtWarn<
   "'main' is not allowed to be declared _Noreturn">, InGroup<Main>;
 def note_main_remove_noreturn : Note<"remove '_Noreturn'">;
 def err_constexpr_main : Error<
-  "'main' is not allowed to be declared constexpr">;
+  "'main' is not allowed to be declared %select{constexpr|consteval}0">;
 def err_deleted_main : Error<"'main' is not allowed to be deleted">;
 def err_mainlike_template_decl : Error<"%0 cannot be a template">;
 def err_main_returns_nonint : Error<"'main' must return 'int'">;
 def ext_main_returns_nonint : ExtWarn<"return type of 'main' is not 'int'">,
     InGroup<MainReturnType>;
 def note_main_change_return_type : Note<"change return type to 'int'">;
 def err_main_surplus_args : Error<"too many parameters (%0) for 'main': "
     "must be 0, 2, or 3">;
def ext_mutable_reference : ExtWarn<
   "'mutable' on a reference type is a Microsoft extension">,
   InGroup<MicrosoftMutableReference>;
 def err_mutable_const : Error<"'mutable' and 'const' cannot be mixed">;
 def err_mutable_nonmember : Error<
   "'mutable' can only be applied to member variables">;
 def err_virtual_in_union : Error<
   "unions cannot have virtual functions">;
 def err_virtual_non_function : Error<
   "'virtual' can only appear on non-static member functions">;
 def err_virtual_out_of_class : Error<
   "'virtual' can only be specified inside the class definition">;
 def err_virtual_member_function_template : Error<
   "'virtual' cannot be specified on member function templates">;
 def err_static_overrides_virtual : Error<
   "'static' member function %0 overrides a virtual function in a base class">;
 def err_explicit_non_function : Error<
   "'explicit' can only appear on non-static member functions">;

 def warn_for_range_copy : Warning<
   "loop variable %0 of type %1 creates a copy from type %2">,
   InGroup<RangeLoopAnalysis>, DefaultIgnore;
 def note_use_reference_type : Note<"use reference type %0 to prevent copying">;
 def err_objc_for_range_init_stmt : Error<
   "initialization statement is not supported when iterating over Objective-C "
   "collection">;
 
-// C++11 constexpr
+// C++11 constexpr and C++2a consteval
 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_incompatible_constexpr_consteval : Error<
+  "constexpr specifier is incompatible with consteval specifier">;
+def err_consteval_cannot_be_constant_eval : Error<
+  "call to %0 cannot be constant evaluated">;
+def note_argument_n_cannot_be_constant_eval : Note<
+  "argument %0 cannot be constant evaluated">;
+def note_not_constexpr_this : Note<
+  "call to member of non-constexpr value">;
 def err_invalid_constexpr : Error<
   "%select{function parameter|typedef|non-static data member}0 "
   "cannot be constexpr">;
 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 constexpr">;
-def err_constexpr_dtor : Error<"destructor cannot be marked constexpr">;
+def err_constexpr_dtor : Error<"destructor cannot be marked %0">;
+def err_invalid_consteval_decl_kind : Error<
+  "operator %select{new|delete|new[]|delete[]}0 cannot be marked consteval">;
+def err_take_adress_of_consteval_decl : Error<
+  "taking address of a %0">;
 def err_constexpr_no_declarators : Error<
   "constexpr can only be used in variable and function declarations">;
 def err_invalid_constexpr_var_decl : Error<
   "constexpr variable declaration must be a definition">;
 def err_constexpr_static_mem_var_requires_init : Error<
   "declaration of constexpr static data member %0 requires an initializer">;
 def err_constexpr_var_non_literal : Error<
   "constexpr variable cannot have non-literal type %0">;
 def err_constexpr_var_requires_const_init : Error<
   "constexpr variable %0 must be initialized by a constant expression">;
 def err_constexpr_redecl_mismatch : Error<
-  "%select{non-constexpr declaration of %0 follows constexpr declaration"
-  "|constexpr declaration of %0 follows non-constexpr declaration}1">;
+  "%select{non-%2 declaration of %0 follows %2 declaration"
+  "|%2 declaration of %0 follows non-%2 declaration}1">;
 def err_constexpr_virtual : Error<"virtual function cannot be constexpr">;
 def err_constexpr_virtual_base : Error<
   "constexpr %select{member function|constructor}0 not allowed in "
   "%select{struct|interface|class}1 with virtual base "
   "%plural{1:class|:classes}2">;
 def note_non_literal_incomplete : Note<
   "incomplete type %0 is not a literal type">;
 def note_non_literal_virtual_base : Note<"%select{struct|interface|class}0 "

 def err_defaulted_copy_assign_not_ref : Error<
   "the parameter for an explicitly-defaulted copy assignment operator must be an "
   "lvalue reference type">;
 def err_incorrect_defaulted_constexpr : Error<
   "defaulted definition of %sub{select_special_member_kind}0 "
   "is not constexpr">;
 def warn_defaulted_method_deleted : Warning<
   "explicitly defaulted %sub{select_special_member_kind}0 is implicitly "
   "deleted">, InGroup<DiagGroup<"defaulted-function-deleted">>;
 def err_out_of_line_default_deletes : Error<
   "defaulting this %sub{select_special_member_kind}0 "
   "would delete it after its first declaration">;
 def note_deleted_type_mismatch : Note<
   "function is implicitly deleted because its declared type does not match "
   "the type of an implicit %sub{select_special_member_kind}0">;
 def warn_cxx17_compat_defaulted_method_type_mismatch : Warning<
   "explicitly defaulting this %sub{select_special_member_kind}0 with a type "

 def err_coroutine_within_handler : Error<
   "'%0' cannot be used in the handler of a try block">;
 def err_coroutine_outside_function : Error<
   "'%0' cannot be used outside a function">;
 def err_coroutine_invalid_func_context : Error<
   "'%1' cannot be used in %select{a constructor|a destructor"
   "|a copy assignment operator|a move assignment operator|the 'main' function"
   "|a constexpr function|a function with a deduced return type"
-  "|a varargs function}0">;
+  "|a varargs function|a consteval function}0">;
 def err_implied_coroutine_type_not_found : Error<
   "%0 type was not found; include <experimental/coroutine> before defining "
   "a coroutine">;
 def err_implicit_coroutine_std_nothrow_type_not_found : Error<
   "std::nothrow was not found; include <new> before defining a coroutine which "
   "uses get_return_object_on_allocation_failure()">;
 def err_malformed_std_nothrow : Error<
   "std::nothrow must be a valid variable declaration">;

 def err_multiversion_diff : Error<
   "multiversioned function declaration has a different %select{calling convention"
   "|return type|constexpr specification|inline specification|storage class|"
   "linkage}0">;
 def err_multiversion_doesnt_support : Error<
   "attribute '%select{target|cpu_specific|cpu_dispatch}0' multiversioned functions do not "
   "yet support %select{function templates|virtual functions|"
   "deduced return types|constructors|destructors|deleted functions|"
-  "defaulted functions|constexpr functions}1">;
+  "defaulted functions|constexpr functions|consteval functions}1">;
 def err_multiversion_not_allowed_on_main : Error<
   "'main' cannot be a multiversioned function">;
 def err_multiversion_not_supported : Error<
  "function multiversioning is not supported on the current target">;
 def err_multiversion_types_mixed : Error<
   "multiversioning attributes cannot be combined">;
 def err_cpu_dispatch_mismatch : Error<
  "'cpu_dispatch' function redeclared with different CPUs">;

clang/include/clang/Basic/TokenKinds.def

 
 // C++ modules TS keywords
 MODULES_KEYWORD(module)
 MODULES_KEYWORD(import)
 
 // C++ char8_t proposal
 CXX2A_KEYWORD(char8_t               , CHAR8SUPPORT)
 
+// C++ consteval proposal
+CXX2A_KEYWORD(consteval             , 0)
+
 // C11 Extension
 KEYWORD(_Float16                    , KEYALL)
 
 // ISO/IEC JTC1 SC22 WG14 N1169 Extension
 KEYWORD(_Accum                      , KEYNOCXX)
 KEYWORD(_Fract                      , KEYNOCXX)
 KEYWORD(_Sat                        , KEYNOCXX)
 

clang/include/clang/Sema/DeclSpec.h

private:
   unsigned FS_noreturn_specified : 1;
 
   // friend-specifier
   unsigned Friend_specified : 1;
 
   // constexpr-specifier
   unsigned Constexpr_specified : 1;
 
+  // consteval-specifier
+  unsigned Consteval_specified : 1;
+
   union {
     UnionParsedType TypeRep;
     Decl *DeclRep;
     Expr *ExprRep;
   };
 
   /// ExplicitSpecifier - Store information about explicit spicifer.
   ExplicitSpecifier FS_explicit_specifier;
private:
   /// TSTNameLoc provides source range info for tag types.
   SourceLocation TSTNameLoc;
   SourceRange TypeofParensRange;
   SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc, TQ_atomicLoc,
       TQ_unalignedLoc;
   SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc, FS_noreturnLoc;
   SourceLocation FS_explicitCloseParenLoc;
   SourceLocation FS_forceinlineLoc;
-  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc;
+  SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc, ConstevalLoc;
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
   void SaveWrittenBuiltinSpecs();
 
   ObjCDeclSpec *ObjCQualifiers;
 
   static bool isTypeRep(TST T) {
DeclSpec(AttributeFactory &attrFactory)
         SCS_extern_in_linkage_spec(false), TypeSpecWidth(TSW_unspecified),
         TypeSpecComplex(TSC_unspecified), TypeSpecSign(TSS_unspecified),
         TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
         TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
         TypeSpecPipe(false), TypeSpecSat(false), TypeQualifiers(TQ_unspecified),
         FS_inline_specified(false), FS_forceinline_specified(false),
         FS_virtual_specified(false), FS_noreturn_specified(false),
         Friend_specified(false), Constexpr_specified(false),
-        FS_explicit_specifier(), Attrs(attrFactory), writtenBS(),
-        ObjCQualifiers(nullptr) {}
+        Consteval_specified(false), FS_explicit_specifier(), Attrs(attrFactory),
+        writtenBS(), ObjCQualifiers(nullptr) {}
 
   // storage-class-specifier
   SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; }
   TSCS getThreadStorageClassSpec() const {
     return (TSCS)ThreadStorageClassSpec;
   }
   bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; }
   void setExternInLinkageSpec(bool Value) {
public:
 
   bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec,
                      unsigned &DiagID);
   bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec,
                             unsigned &DiagID);
   bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec,
                         unsigned &DiagID);
 
+  bool SetConstevalSpec(SourceLocation Loc, const char *&PrevSpec,
+                        unsigned &DiagID);
+
   bool isFriendSpecified() const { return Friend_specified; }
   SourceLocation getFriendSpecLoc() const { return FriendLoc; }
 
   bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); }
   SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; }
 
   bool isConstexprSpecified() const { return Constexpr_specified; }
   SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; }
 
   void ClearConstexprSpec() {
     Constexpr_specified = false;
     ConstexprLoc = SourceLocation();
   }
 
+  bool isConstevalSpecified() const { return Consteval_specified; }
+  SourceLocation getConstevalSpecLoc() const { return ConstevalLoc; }
+
+  void ClearConstevalSpec() {
+    Consteval_specified = false;
+    ConstevalLoc = SourceLocation();
+  }
+
   AttributePool &getAttributePool() const {
     return Attrs.getPool();
   }
 
   /// Concatenates two attribute lists.
   ///
   /// The GCC attribute syntax allows for the following:
   ///

clang/include/clang/Sema/Sema.h

enum class ExpressionEvaluationContext {
     /// definitions from being required, but not in other ways.
     DiscardedStatement,
 
     /// The current expression occurs within an unevaluated
     /// operand that unconditionally permits abstract references to
     /// fields, such as a SIZE operator in MS-style inline assembly.
     UnevaluatedAbstract,
 
-    /// The current context is "potentially evaluated" in C++11 terms,
-    /// but the expression is evaluated at compile-time (like the values of
-    /// cases in a switch statement).
+    /// The current context is either of:
+    /// - "potentially evaluated" in C++11 terms,
+    ///   but the expression is evaluated at compile-time (like the values of
+    ///   cases in a switch statement).
+    /// - "immediate function context" in C++2a terms, a call to a function
+    ///   marked as consteval
     ConstantEvaluated,
 
     /// The current expression is potentially evaluated at run time,
     /// which means that code may be generated to evaluate the value of the
     /// expression at run time.
     PotentiallyEvaluated,
 
     /// The current expression is potentially evaluated, but any
StmtResult ActOnSEHExceptBlock(SourceLocation Loc,
                                  Stmt *Block);
   void ActOnStartSEHFinallyBlock();
   void ActOnAbortSEHFinallyBlock();
   StmtResult ActOnFinishSEHFinallyBlock(SourceLocation Loc, Stmt *Block);
   StmtResult ActOnSEHLeaveStmt(SourceLocation Loc, Scope *CurScope);
 
   void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
 
+  /// CheckInvalidConstevalCall - detect and diagnose invalid calls to
+  /// consteval function.
+  /// return true if the call is invalid.
+  bool CheckInvalidConstevalCall(FunctionDecl *FDecl, SourceLocation Loc,
+                                 ArrayRef<Expr *> Args, Expr *This = nullptr);
+
+  /// CheckInvalidConstevalTakeAddress - detect and diagnose if Input is a
+  /// DeclRef to a consteval function. return true if the operation is forbiden.
+  bool CheckInvalidConstevalTakeAddress(Expr *Input);
+
   bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
 
   /// If it's a file scoped decl that must warn if not used, keep track
   /// of it.
   void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
 
   /// DiagnoseUnusedExprResult - If the statement passed in is an expression
   /// whose result is unused, warn.
public:
 
   /// Create a new lambda closure type.
   CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
                                          TypeSourceInfo *Info,
                                          bool KnownDependent,
                                          LambdaCaptureDefault CaptureDefault);
 
   /// Start the definition of a lambda expression.
-  CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
-                                       SourceRange IntroducerRange,
-                                       TypeSourceInfo *MethodType,
-                                       SourceLocation EndLoc,
-                                       ArrayRef<ParmVarDecl *> Params,
-                                       bool IsConstexprSpecified);
+  CXXMethodDecl *
+  startLambdaDefinition(CXXRecordDecl *Class, SourceRange IntroducerRange,
+                        TypeSourceInfo *MethodType, SourceLocation EndLoc,
+                        bool IsConstexprSpecified, bool IsConstevalSpecified);
 
   /// Endow the lambda scope info with the relevant properties.
   void buildLambdaScope(sema::LambdaScopeInfo *LSI,
                         CXXMethodDecl *CallOperator,
                         SourceRange IntroducerRange,
                         LambdaCaptureDefault CaptureDefault,
                         SourceLocation CaptureDefaultLoc,
                         bool ExplicitParams,
public:
   static bool isCast(CheckedConversionKind CCK) {
     return CCK == CCK_CStyleCast || CCK == CCK_FunctionalCast ||
            CCK == CCK_OtherCast;
   }
 
   /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
   /// cast.  If there is already an implicit cast, merge into the existing one.
   /// If isLvalue, the result of the cast is an lvalue.
-  ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
-                               ExprValueKind VK = VK_RValue,
-                               const CXXCastPath *BasePath = nullptr,
-                               CheckedConversionKind CCK
-                                  = CCK_ImplicitConversion);
+  ExprResult
+  ImpCastExprToType(Expr *E, QualType Type, CastKind CK,
+                    CheckedConversionKind CCK = CCK_ImplicitConversion,
+                    bool isCastForCall = false);
 
   /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
   /// to the conversion from scalar type ScalarTy to the Boolean type.
   static CastKind ScalarTypeToBooleanCastKind(QualType ScalarTy);
 
   /// IgnoredValueConversions - Given that an expression's result is
   /// syntactically ignored, perform any conversions that are
   /// required.

clang/lib/AST/ASTImporter.cpp

if (FromConstructor->getExplicitSpecifier().getExpr()) {
       std::tie(ExplicitExpr) = *Imp;
     }
     if (GetImportedOrCreateDecl<CXXConstructorDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo,
             ExplicitSpecifier(
                 ExplicitExpr,
                 FromConstructor->getExplicitSpecifier().getKind()),
-            D->isInlineSpecified(), D->isImplicit(), D->isConstexpr()))
+            D->isInlineSpecified(), D->isImplicit(), D->isConstexpr(),
+            D->isConsteval()))
       return ToFunction;
   } else if (CXXDestructorDecl *FromDtor = dyn_cast<CXXDestructorDecl>(D)) {
 
     auto Imp =
         importSeq(const_cast<FunctionDecl *>(FromDtor->getOperatorDelete()),
                   FromDtor->getOperatorDeleteThisArg());
 
     if (!Imp)
if (FromConversion->getExplicitSpecifier().getExpr()) {
         return Imp.takeError();
       std::tie(ExplicitExpr) = *Imp;
     }
     if (GetImportedOrCreateDecl<CXXConversionDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo, D->isInlineSpecified(),
             ExplicitSpecifier(ExplicitExpr,
                               FromConversion->getExplicitSpecifier().getKind()),
-            D->isConstexpr(), SourceLocation()))
+            D->isConstexpr(), D->isConsteval(), SourceLocation()))
       return ToFunction;
   } else if (auto *Method = dyn_cast<CXXMethodDecl>(D)) {
     if (GetImportedOrCreateDecl<CXXMethodDecl>(
             ToFunction, D, Importer.getToContext(), cast<CXXRecordDecl>(DC),
             ToInnerLocStart, NameInfo, T, TInfo, Method->getStorageClass(),
-            Method->isInlineSpecified(), D->isConstexpr(), SourceLocation()))
+            Method->isInlineSpecified(), D->isConstexpr(), D->isConsteval(),
+            SourceLocation()))
       return ToFunction;
   } else {
-    if (GetImportedOrCreateDecl(ToFunction, D, Importer.getToContext(), DC,
-                                ToInnerLocStart, NameInfo, T, TInfo,
-                                D->getStorageClass(), D->isInlineSpecified(),
-                                D->hasWrittenPrototype(), D->isConstexpr()))
+    if (GetImportedOrCreateDecl(
+            ToFunction, D, Importer.getToContext(), DC, ToInnerLocStart,
+            NameInfo, T, TInfo, D->getStorageClass(), D->isInlineSpecified(),
+            D->hasWrittenPrototype(), D->isConstexpr(), D->isConsteval()))
       return ToFunction;
   }
 
   // Connect the redecl chain.
   if (FoundByLookup) {
     auto *Recent = const_cast<FunctionDecl *>(
           FoundByLookup->getMostRecentDecl());
     ToFunction->setPreviousDecl(Recent);

clang/lib/AST/Decl.cpp

 //===----------------------------------------------------------------------===//
 // FunctionDecl Implementation
 //===----------------------------------------------------------------------===//
 
 FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
                            SourceLocation StartLoc,
                            const DeclarationNameInfo &NameInfo, QualType T,
                            TypeSourceInfo *TInfo, StorageClass S,
-                           bool isInlineSpecified, bool isConstexprSpecified)
+                           bool isInlineSpecified, bool isConstexprSpecified,
+                           bool isConstevalSpecified)
     : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
                      StartLoc),
       DeclContext(DK), redeclarable_base(C), ODRHash(0),
       EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
   assert(T.isNull() || T->isFunctionType());
   FunctionDeclBits.SClass = S;
   FunctionDeclBits.IsInline = isInlineSpecified;
   FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
   FunctionDeclBits.IsVirtualAsWritten = false;
   FunctionDeclBits.IsPure = false;
   FunctionDeclBits.HasInheritedPrototype = false;
   FunctionDeclBits.HasWrittenPrototype = true;
   FunctionDeclBits.IsDeleted = false;
   FunctionDeclBits.IsTrivial = false;
   FunctionDeclBits.IsTrivialForCall = false;
   FunctionDeclBits.IsDefaulted = false;
   FunctionDeclBits.IsExplicitlyDefaulted = false;
   FunctionDeclBits.HasImplicitReturnZero = false;
   FunctionDeclBits.IsLateTemplateParsed = false;
   FunctionDeclBits.IsConstexpr = isConstexprSpecified;
+  FunctionDeclBits.IsConsteval = isConstevalSpecified;
   FunctionDeclBits.InstantiationIsPending = false;
   FunctionDeclBits.UsesSEHTry = false;
   FunctionDeclBits.HasSkippedBody = false;
   FunctionDeclBits.WillHaveBody = false;
   FunctionDeclBits.IsMultiVersion = false;
   FunctionDeclBits.IsCopyDeductionCandidate = false;
   FunctionDeclBits.HasODRHash = false;
 }
ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, QualType Type,
   return new (C, nullptr) ImplicitParamDecl(C, Type, ParamKind);
 }
 
 ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C,
                                                          unsigned ID) {
   return new (C, ID) ImplicitParamDecl(C, QualType(), ImplicitParamKind::Other);
 }
 
-FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
-                                   SourceLocation StartLoc,
-                                   const DeclarationNameInfo &NameInfo,
-                                   QualType T, TypeSourceInfo *TInfo,
-                                   StorageClass SC,
-                                   bool isInlineSpecified,
-                                   bool hasWrittenPrototype,
-                                   bool isConstexprSpecified) {
-  FunctionDecl *New =
-      new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
-                               SC, isInlineSpecified, isConstexprSpecified);
+FunctionDecl *
+FunctionDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+                     const DeclarationNameInfo &NameInfo, QualType T,
+                     TypeSourceInfo *TInfo, StorageClass SC,
+                     bool isInlineSpecified, bool hasWrittenPrototype,
+                     bool isConstexprSpecified, bool isConstevalSpecified) {
+  FunctionDecl *New = new (C, DC) FunctionDecl(
+      Function, C, DC, StartLoc, NameInfo, T, TInfo, SC, isInlineSpecified,
+      isConstexprSpecified, isConstevalSpecified);
   New->setHasWrittenPrototype(hasWrittenPrototype);
   return New;
 }
 
 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
                                   DeclarationNameInfo(), QualType(), nullptr,
-                                  SC_None, false, false);
+                                  SC_None, false, false, false);
 }
 
 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
   return new (C, DC) BlockDecl(DC, L);
 }
 
 BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) BlockDecl(nullptr, SourceLocation());

clang/lib/AST/DeclCXX.cpp

if (!Constructor->isImplicit()) {
       data().PlainOldData = false;
     }
 
     if (Constructor->isDefaultConstructor()) {
       SMKind |= SMF_DefaultConstructor;
 
       if (Constructor->isUserProvided())
         data().UserProvidedDefaultConstructor = true;
-      if (Constructor->isConstexpr())
+      if (Constructor->isConstexprOrConsteval())
         data().HasConstexprDefaultConstructor = true;
       if (Constructor->isDefaulted())
         data().HasDefaultedDefaultConstructor = true;
     }
 
     if (!FunTmpl) {
       unsigned Quals;
       if (Constructor->isCopyConstructor(Quals)) {
void CXXRecordDecl::addedMember(Decl *D) {
   // Handle constructors, including those inherited from base classes.
   if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {
     // Record if we see any constexpr constructors which are neither copy
     // nor move constructors.
     // C++1z [basic.types]p10:
     //   [...] has at least one constexpr constructor or constructor template
     //   (possibly inherited from a base class) that is not a copy or move
     //   constructor [...]
-    if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
+    if ((Constructor->isConstexprOrConsteval()) &&
+        !Constructor->isCopyOrMoveConstructor())
       data().HasConstexprNonCopyMoveConstructor = true;
   }
 
   // Handle destructors.
   if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) {
     SMKind |= SMF_Destructor;
 
     if (DD->isUserProvided())
void CXXRecordDecl::finishedDefaultedOrDeletedMember(CXXMethodDecl *D) {
   assert(!D->isImplicit() && !D->isUserProvided());
 
   // The kind of special member this declaration is, if any.
   unsigned SMKind = 0;
 
   if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     if (Constructor->isDefaultConstructor()) {
       SMKind |= SMF_DefaultConstructor;
-      if (Constructor->isConstexpr())
+      if (Constructor->isConstexprOrConsteval())
         data().HasConstexprDefaultConstructor = true;
     }
     if (Constructor->isCopyConstructor())
       SMKind |= SMF_CopyConstructor;
     else if (Constructor->isMoveConstructor())
       SMKind |= SMF_MoveConstructor;
     else if (Constructor->isConstexpr())
       // We may now know that the constructor is constexpr.
for (const auto &I : RD->bases()) {
     CXXMethodDecl *T = this->getCorrespondingMethodInClass(Base);
     if (T)
       return T;
   }
 
   return nullptr;
 }
 
-CXXMethodDecl *
-CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
+CXXMethodDecl *CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
                                      SourceLocation StartLoc,
                                      const DeclarationNameInfo &NameInfo,
                                      QualType T, TypeSourceInfo *TInfo,
                                      StorageClass SC, bool isInline,
-                      bool isConstexpr, SourceLocation EndLocation) {
-  return new (C, RD) CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo,
-                                   T, TInfo, SC, isInline, isConstexpr,
-                                   EndLocation);
+                                     bool isConstexpr, bool isConsteval,
+                                     SourceLocation EndLocation) {
+  return new (C, RD)
+      CXXMethodDecl(CXXMethod, C, RD, StartLoc, NameInfo, T, TInfo, SC,
+                    isInline, isConstexpr, isConsteval, EndLocation);
 }
 
 CXXMethodDecl *CXXMethodDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
-  return new (C, ID) CXXMethodDecl(CXXMethod, C, nullptr, SourceLocation(),
-                                   DeclarationNameInfo(), QualType(), nullptr,
-                                   SC_None, false, false, SourceLocation());
+  return new (C, ID) CXXMethodDecl(
+      CXXMethod, C, nullptr, SourceLocation(), DeclarationNameInfo(),
+      QualType(), nullptr, SC_None, false, false, false, SourceLocation());
 }
 
 CXXMethodDecl *CXXMethodDecl::getDevirtualizedMethod(const Expr *Base,
                                                      bool IsAppleKext) {
   assert(isVirtual() && "this method is expected to be virtual");
 
   // When building with -fapple-kext, all calls must go through the vtable since
   // the kernel linker can do runtime patching of vtables.
SourceRange CXXCtorInitializer::getSourceRange() const {
 
   return SourceRange(getSourceLocation(), getRParenLoc());
 }
 
 CXXConstructorDecl::CXXConstructorDecl(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
     const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
     ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
-    bool isConstexpr, InheritedConstructor Inherited)
+    bool isConstexpr, bool isConsteval, InheritedConstructor Inherited)
     : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
-                    SC_None, isInline, isConstexpr, SourceLocation()) {
+                    SC_None, isInline, isConstexpr, isConsteval,
+                    SourceLocation()) {
   setNumCtorInitializers(0);
   setInheritingConstructor(static_cast<bool>(Inherited));
   setImplicit(isImplicitlyDeclared);
   CXXConstructorDeclBits.HasTrailingExplicitSpecifier = ES.getExpr() ? 1 : 0;
   if (Inherited)
     *getTrailingObjects<InheritedConstructor>() = Inherited;
   setExplicitSpecifier(ES);
 }
 
 void CXXConstructorDecl::anchor() {}
 
 CXXConstructorDecl *CXXConstructorDecl::CreateDeserialized(ASTContext &C,
                                                            unsigned ID,
                                                            uint64_t AllocKind) {
   bool hasTraillingExplicit = static_cast<bool>(AllocKind & TAKHasTailExplicit);
   bool isInheritingConstructor =
       static_cast<bool>(AllocKind & TAKInheritsConstructor);
   unsigned Extra =
       additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
           isInheritingConstructor, hasTraillingExplicit);
   auto *Result = new (C, ID, Extra) CXXConstructorDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
-      ExplicitSpecifier(), false, false, false, InheritedConstructor());
+      ExplicitSpecifier(), false, false, false, false, InheritedConstructor());
   Result->setInheritingConstructor(isInheritingConstructor);
   Result->CXXConstructorDeclBits.HasTrailingExplicitSpecifier =
       hasTraillingExplicit;
   Result->setExplicitSpecifier(ExplicitSpecifier());
   return Result;
 }
 
 CXXConstructorDecl *CXXConstructorDecl::Create(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
     const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
     ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
-    bool isConstexpr, InheritedConstructor Inherited) {
+    bool isConstexpr, bool isConsteval, InheritedConstructor Inherited) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConstructorName &&
          "Name must refer to a constructor");
   unsigned Extra =
       additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
           Inherited ? 1 : 0, ES.getExpr() ? 1 : 0);
-  return new (C, RD, Extra)
-      CXXConstructorDecl(C, RD, StartLoc, NameInfo, T, TInfo, ES, isInline,
-                         isImplicitlyDeclared, isConstexpr, Inherited);
+  return new (C, RD, Extra) CXXConstructorDecl(
+      C, RD, StartLoc, NameInfo, T, TInfo, ES, isInline, isImplicitlyDeclared,
+      isConstexpr, isConsteval, Inherited);
 }
 
 CXXConstructorDecl::init_const_iterator CXXConstructorDecl::init_begin() const {
   return CtorInitializers.get(getASTContext().getExternalSource());
 }
 
 CXXConstructorDecl *CXXConstructorDecl::getTargetConstructor() const {
   assert(isDelegatingConstructor() && "Not a delegating constructor!");

 }
 
 void CXXConversionDecl::anchor() {}
 
 CXXConversionDecl *
 CXXConversionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
   return new (C, ID) CXXConversionDecl(
       C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
-      false, ExplicitSpecifier(), false, SourceLocation());
+      false, ExplicitSpecifier(), false, false, SourceLocation());
 }
 
 CXXConversionDecl *CXXConversionDecl::Create(
     ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
     const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
-    bool isInline, ExplicitSpecifier ES, bool isConstexpr,
+    bool isInline, ExplicitSpecifier ES, bool isConstexpr, bool isConsteval,
     SourceLocation EndLocation) {
   assert(NameInfo.getName().getNameKind()
          == DeclarationName::CXXConversionFunctionName &&
          "Name must refer to a conversion function");
-  return new (C, RD) CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo,
-                                       isInline, ES, isConstexpr, EndLocation);
+  return new (C, RD)
+      CXXConversionDecl(C, RD, StartLoc, NameInfo, T, TInfo, isInline, ES,
+                        isConstexpr, isConsteval, EndLocation);
 }
 
 bool CXXConversionDecl::isLambdaToBlockPointerConversion() const {
   return isImplicit() && getParent()->isLambda() &&
          getConversionType()->isBlockPointerType();
 }
 
 LinkageSpecDecl::LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,

clang/lib/AST/DeclPrinter.cpp

if (!Policy.SuppressSpecifiers) {
     case SC_PrivateExtern: Out << "__private_extern__ "; break;
     case SC_Auto: case SC_Register:
       llvm_unreachable("invalid for functions");
     }
 
     if (D->isInlineSpecified())  Out << "inline ";
     if (D->isVirtualAsWritten()) Out << "virtual ";
     if (D->isModulePrivate())    Out << "__module_private__ ";
-    if (D->isConstexpr() && !D->isExplicitlyDefaulted()) Out << "constexpr ";
+    if (D->isConstexpr() && !D->isExplicitlyDefaulted())
+      Out << "constexpr ";
+    if (D->isConsteval() && !D->isExplicitlyDefaulted())
+      Out << "consteval ";
     ExplicitSpecifier ExplicitSpec = ExplicitSpecifier::getFromDecl(D);
     if (ExplicitSpec.isSpecified())
       printExplicitSpecifier(ExplicitSpec, Out, Policy, Indentation);
   }
 
   PrintingPolicy SubPolicy(Policy);
   SubPolicy.SuppressSpecifiers = false;
   std::string Proto;

clang/lib/AST/ExprConstant.cpp

static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
                                            const CXXConstructorDecl *CD,
                                            bool IsValueInitialization) {
   if (!CD->isTrivial() || !CD->isDefaultConstructor())
     return false;
 
   // Value-initialization does not call a trivial default constructor, so such a
   // call is a core constant expression whether or not the constructor is
   // constexpr.
-  if (!CD->isConstexpr() && !IsValueInitialization) {
+  if (!CD->isConstexprOrConsteval() && !IsValueInitialization) {
     if (Info.getLangOpts().CPlusPlus11) {
       // FIXME: If DiagDecl is an implicitly-declared special member function,
       // we should be much more explicit about why it's not constexpr.
       Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1)
         << /*IsConstexpr*/0 << /*IsConstructor*/1 << CD;
       Info.Note(CD->getLocation(), diag::note_declared_at);
     } else {
       Info.CCEDiag(Loc, diag::note_invalid_subexpr_in_const_expr);
     }
   }
   return true;
 }
 
 /// CheckConstexprFunction - Check that a function can be called in a constant
 /// expression.
 static bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc,
                                    const FunctionDecl *Declaration,
                                    const FunctionDecl *Definition,
                                    const Stmt *Body) {
   // Potential constant expressions can contain calls to declared, but not yet
   // defined, constexpr functions.
   if (Info.checkingPotentialConstantExpression() && !Definition &&
-      Declaration->isConstexpr())
+      Declaration->isConstexprOrConsteval())
     return false;
 
   // Bail out if the function declaration itself is invalid.  We will
   // have produced a relevant diagnostic while parsing it, so just
   // note the problematic sub-expression.
   if (Declaration->isInvalidDecl()) {
     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
     return false;
   }
 
   // Can we evaluate this function call?
-  if (Definition && Definition->isConstexpr() &&
+  if (Definition && Definition->isConstexprOrConsteval() &&
       !Definition->isInvalidDecl() && Body)
     return true;
 
   if (Info.getLangOpts().CPlusPlus11) {
     const FunctionDecl *DiagDecl = Definition ? Definition : Declaration;
 
     // If this function is not constexpr because it is an inherited
     // non-constexpr constructor, diagnose that directly.
     auto *CD = dyn_cast<CXXConstructorDecl>(DiagDecl);
     if (CD && CD->isInheritingConstructor()) {
       auto *Inherited = CD->getInheritedConstructor().getConstructor();
-      if (!Inherited->isConstexpr())
+      if (!Inherited->isConstexprOrConsteval())
         DiagDecl = CD = Inherited;
     }
 
     // FIXME: If DiagDecl is an implicitly-declared special member function
     // or an inheriting constructor, we should be much more explicit about why
     // it's not constexpr.
     if (CD && CD->isInheritingConstructor())
       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1)
         << CD->getInheritedConstructor().getConstructor()->getParent();
     else
       Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1)
-        << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;
+          << DiagDecl->isConstexprOrConsteval() << (bool)CD << DiagDecl;
     Info.Note(DiagDecl->getLocation(), diag::note_declared_at);
   } else {
     Info.FFDiag(CallLoc, diag::note_invalid_subexpr_in_const_expr);
   }
   return false;
 }
 
 /// Determine if a class has any fields that might need to be copied by a
static bool HandleFunctionCall(SourceLocation CallLoc,
 
   CallStackFrame Frame(Info, CallLoc, Callee, This, ArgValues.data());
 
   // For a trivial copy or move assignment, perform an APValue copy. This is
   // essential for unions, where the operations performed by the assignment
   // operator cannot be represented as statements.
   //
   // Skip this for non-union classes with no fields; in that case, the defaulted
   // copy/move does not actually read the object.
   const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Callee);
   if (MD && MD->isDefaulted() &&
       (MD->getParent()->isUnion() ||
        (MD->isTrivial() && hasFields(MD->getParent())))) {
     assert(This &&
            (MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()));
     LValue RHS;
     RHS.setFrom(Info.Ctx, ArgValues[0]);
     APValue RHSValue;

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::Visit(const Decl *D) {
 
   if (D->isUsed())
     OS << " used";
   else if (D->isThisDeclarationReferenced())
     OS << " referenced";
 
   if (D->isInvalidDecl())
     OS << " invalid";
-  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
+  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isConstexpr())
       OS << " constexpr";
+    if (FD->isConsteval())
+      OS << " consteval";
+  }
 
   if (!isa<FunctionDecl>(*D)) {
     const auto *MD = dyn_cast<ObjCMethodDecl>(D);
     if (!MD || !MD->isThisDeclarationADefinition()) {
       const auto *DC = dyn_cast<DeclContext>(D);
       if (DC && DC->hasExternalLexicalStorage()) {
         ColorScope Color(OS, ShowColors, UndeserializedColor);
         OS << " <undeserialized declarations>";

clang/lib/Analysis/ReachableCode.cpp

if (const Expr *Ex = dyn_cast<Expr>(S))
     S = Ex->IgnoreCasts();
 
   bool IgnoreYES_NO = false;
 
   switch (S->getStmtClass()) {
     case Stmt::CallExprClass: {
       const FunctionDecl *Callee =
         dyn_cast_or_null<FunctionDecl>(cast<CallExpr>(S)->getCalleeDecl());
-      return Callee ? Callee->isConstexpr() : false;
+      return Callee ? Callee->isConstexprOrConsteval() : false;
     }
     case Stmt::DeclRefExprClass:
       return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP);
     case Stmt::ObjCBoolLiteralExprClass:
       IgnoreYES_NO = true;
       LLVM_FALLTHROUGH;
     case Stmt::CXXBoolLiteralExprClass:
     case Stmt::IntegerLiteralClass: {

clang/lib/Parse/ParseDecl.cpp

else
       Diag(DS.getThreadStorageClassSpecLoc(),
            diag::err_typename_invalid_storageclass);
     DS.ClearStorageClassSpecs();
   }
 
   // Issue diagnostic and remove function specifier if present.
   if (Specs & DeclSpec::PQ_FunctionSpecifier) {
     if (DS.isInlineSpecified())
-      Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_functionspec);
+      Diag(DS.getInlineSpecLoc(), diag::err_typename_invalid_specifier)
+          << "function";
     if (DS.isVirtualSpecified())
-      Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_functionspec);
+      Diag(DS.getVirtualSpecLoc(), diag::err_typename_invalid_specifier)
+          << "function";
     if (DS.hasExplicitSpecifier())
-      Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_functionspec);
+      Diag(DS.getExplicitSpecLoc(), diag::err_typename_invalid_specifier)
+          << "function";
     DS.ClearFunctionSpecs();
   }
 
-  // Issue diagnostic and remove constexpr specifier if present.
-  if (DS.isConstexprSpecified() && DSC != DeclSpecContext::DSC_condition) {
-    Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_constexpr);
+  // Issue diagnostic and remove constexpr or consteval specifier if present.
+  if (DSC != DeclSpecContext::DSC_condition) {
+    if (DS.isConstexprSpecified()) {
+      Diag(DS.getConstexprSpecLoc(), diag::err_typename_invalid_specifier)
+          << "constexpr";
       DS.ClearConstexprSpec();
     }
+    if (DS.isConstevalSpecified()) {
+      Diag(DS.getConstevalSpecLoc(), diag::err_typename_invalid_specifier)
+          << "consteval";
+      DS.ClearConstevalSpec();
+    }
+  }
 }
 
 /// isValidAfterIdentifierInDeclaratorAfterDeclSpec - Return true if the
 /// specified token is valid after the identifier in a declarator which
 /// immediately follows the declspec.  For example, these things are valid:
 ///
 ///      int x   [             4];         // direct-declarator
 ///      int x   (             int y);     // direct-declarator

 /// [GNU]   '__thread'
 ///       function-specifier: [C99 6.7.4]
 /// [C99]   'inline'
 /// [C++]   'virtual'
 /// [C++]   'explicit'
 /// [OpenCL] '__kernel'
 ///       'friend': [C++ dcl.friend]
 ///       'constexpr': [C++0x dcl.constexpr]
+///       'consteval': [C++2a dcl.constexpr]
 void Parser::ParseDeclarationSpecifiers(DeclSpec &DS,
                                         const ParsedTemplateInfo &TemplateInfo,
                                         AccessSpecifier AS,
                                         DeclSpecContext DSContext,
                                         LateParsedAttrList *LateAttrs) {
   if (DS.getSourceRange().isInvalid()) {
     // Start the range at the current token but make the end of the range
     // invalid.  This will make the entire range invalid unless we successfully
case tok::kw___module_private__:
       isInvalid = DS.setModulePrivateSpec(Loc, PrevSpec, DiagID);
       break;
 
     // constexpr
     case tok::kw_constexpr:
       isInvalid = DS.SetConstexprSpec(Loc, PrevSpec, DiagID);
       break;
 
+    case tok::kw_consteval:
+      isInvalid = DS.SetConstevalSpec(Loc, PrevSpec, DiagID);
+      break;
+
     // type-specifier
     case tok::kw_short:
       isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_short, Loc, PrevSpec,
                                       DiagID, Policy);
       break;
     case tok::kw_long:
       if (DS.getTypeSpecWidth() != DeclSpec::TSW_long)
         isInvalid = DS.SetTypeSpecWidth(DeclSpec::TSW_long, Loc, PrevSpec,
case tok::kw_typeof:
 
     // GNU attributes.
   case tok::kw___attribute:
 
     // C++11 decltype and constexpr.
   case tok::annot_decltype:
   case tok::kw_constexpr:
 
+    // C++20 consteval.
+  case tok::kw_consteval:
+
     // C11 _Atomic
   case tok::kw__Atomic:
     return true;
 
     // GNU ObjC bizarre protocol extension: <proto1,proto2> with implicit 'id'.
   case tok::less:
     return getLangOpts().ObjC;
 

clang/lib/Parse/ParseExprCXX.cpp

if (!ParseLambdaIntroducer(Intro)) {
     PA2.Commit();
     return false;
   }
 
   PA2.Revert();
   return true;
 }
 
-static void
-tryConsumeMutableOrConstexprToken(Parser &P, SourceLocation &MutableLoc,
+static void tryConsumeLambdaSpecifierToken(Parser &P,
+                                           SourceLocation &MutableLoc,
                                            SourceLocation &ConstexprLoc,
+                                           SourceLocation &ConstevalLoc,
                                            SourceLocation &DeclEndLoc) {
   assert(MutableLoc.isInvalid());
   assert(ConstexprLoc.isInvalid());
   // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
   // to the final of those locations. Emit an error if we have multiple
   // copies of those keywords and recover.
 
   while (true) {
     switch (P.getCurToken().getKind()) {
case tok::kw_constexpr:
       if (ConstexprLoc.isValid()) {
         P.Diag(P.getCurToken().getLocation(),
                diag::err_lambda_decl_specifier_repeated)
             << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
       }
       ConstexprLoc = P.ConsumeToken();
       DeclEndLoc = ConstexprLoc;
       break /*switch*/;
+    case tok::identifier:
+      if (P.getCurToken().getIdentifierInfo()->getName() != "consteval")
+        return;
+      // Diagnostic has already been emitted by the Lexer.
+      LLVM_FALLTHROUGH;
+    case tok::kw_consteval:
+      if (ConstevalLoc.isValid()) {
+        P.Diag(P.getCurToken().getLocation(),
+               diag::err_lambda_decl_specifier_repeated)
+            << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
+      }
+      ConstevalLoc = P.ConsumeToken();
+      DeclEndLoc = ConstevalLoc;
+      break /*switch*/;
     default:
       return;
     }
   }
 }
 
 static void
 addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
                                   DeclSpec &DS) {
   if (ConstexprLoc.isValid()) {
     P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
                              ? diag::ext_constexpr_on_lambda_cxx17
                              : diag::warn_cxx14_compat_constexpr_on_lambda);
     const char *PrevSpec = nullptr;
     unsigned DiagID = 0;
     DS.SetConstexprSpec(ConstexprLoc, PrevSpec, DiagID);
     assert(PrevSpec == nullptr && DiagID == 0 &&
            "Constexpr cannot have been set previously!");
   }
 }
 
+static void addConstevalToLambdaDeclSpecifier(Parser &P,
+                                              SourceLocation ConstevalLoc,
+                                              DeclSpec &DS) {
+  if (ConstevalLoc.isValid()) {
+    const char *PrevSpec = nullptr;
+    unsigned DiagID = 0;
+    DS.SetConstevalSpec(ConstevalLoc, PrevSpec, DiagID);
+    assert(PrevSpec == nullptr && DiagID == 0 &&
+           "Consteval cannot have been set previously!");
+  }
+}
+
 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
 /// expression.
 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                      LambdaIntroducer &Intro) {
   SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
   Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
 
   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
if (Tok.is(tok::l_paren)) {
     // GNU-style attributes must be parsed before the mutable specifier to be
     // compatible with GCC.
     MaybeParseGNUAttributes(Attr, &DeclEndLoc);
 
     // MSVC-style attributes must be parsed before the mutable specifier to be
     // compatible with MSVC.
     MaybeParseMicrosoftDeclSpecs(Attr, &DeclEndLoc);
 
-    // Parse mutable-opt and/or constexpr-opt, and update the DeclEndLoc.
+    // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update the
+    // DeclEndLoc.
     SourceLocation MutableLoc;
     SourceLocation ConstexprLoc;
-    tryConsumeMutableOrConstexprToken(*this, MutableLoc, ConstexprLoc,
-                                      DeclEndLoc);
+    SourceLocation ConstevalLoc;
+    tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
+                                   ConstevalLoc, DeclEndLoc);
 
     addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
-
+    addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
+    DS.Finish(Actions, Actions.getPrintingPolicy());
     // Parse exception-specification[opt].
     ExceptionSpecificationType ESpecType = EST_None;
     SourceRange ESpecRange;
     SmallVector<ParsedType, 2> DynamicExceptions;
     SmallVector<SourceRange, 2> DynamicExceptionRanges;
     ExprResult NoexceptExpr;
     CachedTokens *ExceptionSpecTokens;
     ESpecType = tryParseExceptionSpecification(/*Delayed=*/false,
D.AddTypeInfo(DeclaratorChunk::getFunction(
                       ESpecRange, DynamicExceptions.data(),
                       DynamicExceptionRanges.data(), DynamicExceptions.size(),
                       NoexceptExpr.isUsable() ? NoexceptExpr.get() : nullptr,
                       /*ExceptionSpecTokens*/ nullptr,
                       /*DeclsInPrototype=*/None, LParenLoc, FunLocalRangeEnd, D,
                       TrailingReturnType),
                   std::move(Attr), DeclEndLoc);
   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
-                         tok::kw_constexpr) ||
+                         tok::kw_constexpr, tok::kw_consteval) ||
              (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
     // It's common to forget that one needs '()' before 'mutable', an attribute
     // specifier, or the result type. Deal with this.
     unsigned TokKind = 0;
     switch (Tok.getKind()) {
     case tok::kw_mutable: TokKind = 0; break;
     case tok::arrow: TokKind = 1; break;
     case tok::kw___attribute:
     case tok::l_square: TokKind = 2; break;
     case tok::kw_constexpr: TokKind = 3; break;
+    case tok::kw_consteval:
+      TokKind = 4;
+      break;
     default: llvm_unreachable("Unknown token kind");
     }
 
     Diag(Tok, diag::err_lambda_missing_parens)
       << TokKind
       << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
     SourceLocation DeclEndLoc = DeclLoc;
 

clang/lib/Parse/ParseTentative.cpp

 ///
 ///         decl-specifier:
 ///           storage-class-specifier
 ///           type-specifier
 ///           function-specifier
 ///           'friend'
 ///           'typedef'
 /// [C++11]   'constexpr'
+/// [C++20]   'consteval'
 /// [GNU]     attributes declaration-specifiers[opt]
 ///
 ///         storage-class-specifier:
 ///           'register'
 ///           'static'
 ///           'extern'
 ///           'mutable'
 ///           'auto'
case tok::kw_decltype:
 
     // decl-specifier:
     //   storage-class-specifier
     //   type-specifier
     //   function-specifier
     //   'friend'
     //   'typedef'
     //   'constexpr'
+    //   'consteval'
   case tok::kw_friend:
   case tok::kw_typedef:
   case tok::kw_constexpr:
+  case tok::kw_consteval:
     // storage-class-specifier
   case tok::kw_register:
   case tok::kw_static:
   case tok::kw_extern:
   case tok::kw_mutable:
   case tok::kw_auto:
   case tok::kw___thread:
   case tok::kw_thread_local:

clang/lib/Sema/DeclSpec.cpp

if (Constexpr_specified) {
     PrevSpec = "constexpr";
     return true;
   }
   Constexpr_specified = true;
   ConstexprLoc = Loc;
   return false;
 }
 
+bool DeclSpec::SetConstevalSpec(SourceLocation Loc, const char *&PrevSpec,
+                                unsigned &DiagID) {
+  if (Consteval_specified) {
+    DiagID = diag::ext_warn_duplicate_declspec;
+    PrevSpec = "consteval";
+    return true;
+  }
+  Consteval_specified = true;
+  ConstevalLoc = Loc;
+  return false;
+}
+
 void DeclSpec::SaveWrittenBuiltinSpecs() {
   writtenBS.Sign = getTypeSpecSign();
   writtenBS.Width = getTypeSpecWidth();
   writtenBS.Type = getTypeSpecType();
   // Search the list of attributes for the presence of a mode attribute.
   writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
 }
 
if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 &&
       StorageClassSpec == SCS_auto)
     S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class)
       << FixItHint::CreateRemoval(StorageClassSpecLoc);
   if (TypeSpecType == TST_char8)
     S.Diag(TSTLoc, diag::warn_cxx17_compat_unicode_type);
   else if (TypeSpecType == TST_char16 || TypeSpecType == TST_char32)
     S.Diag(TSTLoc, diag::warn_cxx98_compat_unicode_type)
       << (TypeSpecType == TST_char16 ? "char16_t" : "char32_t");
   if (Constexpr_specified)
     S.Diag(ConstexprLoc, diag::warn_cxx98_compat_constexpr);
 
   // C++ [class.friend]p6:
   //   No storage-class-specifier shall appear in the decl-specifier-seq
   //   of a friend declaration.
   if (isFriendSpecified() &&
       (getStorageClassSpec() || getThreadStorageClassSpec())) {
     SmallString<32> SpecName;
     SourceLocation SCLoc;
if (isFriendSpecified() &&
     }
 
     S.Diag(SCLoc, diag::err_friend_decl_spec)
       << SpecName << StorageHint << ThreadHint;
 
     ClearStorageClassSpecs();
   }
 
+  // C++2a [dcl.spec]p2: The constexpr and consteval decl-specifiers shall not
+  // both appear in a decl-specifier-seq.
+  if (isConstevalSpecified() && isConstexprSpecified()) {
+    S.Diag(ConstexprLoc, diag::err_incompatible_constexpr_consteval)
+        << FixItHint::CreateRemoval(ConstexprLoc);
+    Constexpr_specified = false;
+  }
+
   // C++11 [dcl.fct.spec]p5:
   //   The virtual specifier shall be used only in the initial
   //   declaration of a non-static class member function;
   // C++11 [dcl.fct.spec]p6:
   //   The explicit specifier shall be used only in the declaration of
   //   a constructor or conversion function within its class
   //   definition;
   if (isFriendSpecified() && (isVirtualSpecified() || hasExplicitSpecifier())) {

clang/lib/Sema/Sema.cpp

void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
 
   Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
       << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
 }
 
 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
 /// If there is already an implicit cast, merge into the existing one.
 /// The result is of the given category.
-ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
-                                   CastKind Kind, ExprValueKind VK,
+ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, CastKind Kind,
+                                   ExprValueKind VK,
                                    const CXXCastPath *BasePath,
-                                   CheckedConversionKind CCK) {
+                                   CheckedConversionKind CCK,
+                                   bool isCastForCall) {
 #ifndef NDEBUG
   if (VK == VK_RValue && !E->isRValue()) {
     switch (Kind) {
     default:
       llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
                        "kind");
     case CK_LValueToRValue:
     case CK_ArrayToPointerDecay:
#endif
   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
       ImpCast->setType(Ty);
       ImpCast->setValueKind(VK);
       return E;
     }
   }
 
+  if (Kind == CK_FunctionToPointerDecay && !isCastForCall &&
+      CheckInvalidConstevalTakeAddress(E))
+    return ExprError();
+
   return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
 }
 
 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
 /// to the conversion from scalar type ScalarTy to the Boolean type.
 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
   switch (ScalarTy->getScalarTypeKind()) {
   case Type::STK_Bool: return CK_NoOp;

clang/lib/Sema/SemaCoroutine.cpp

enum InvalidFuncDiag {
     DiagCtor = 0,
     DiagDtor,
     DiagCopyAssign,
     DiagMoveAssign,
     DiagMain,
     DiagConstexpr,
     DiagAutoRet,
     DiagVarargs,
+    DiagConsteval
   };
   bool Diagnosed = false;
   auto DiagInvalid = [&](InvalidFuncDiag ID) {
     S.Diag(Loc, diag::err_coroutine_invalid_func_context) << ID << Keyword;
     Diagnosed = true;
     return false;
   };
 
else if (FD->isMain())
     return DiagInvalid(DiagMain);
 
   // Emit a diagnostics for each of the following conditions which is not met.
   // [expr.const]p2: "An expression e is a core constant expression unless the
   // evaluation of e [...] would evaluate one of the following expressions:
   // [...] an await-expression [...] a yield-expression."
   if (FD->isConstexpr())
     DiagInvalid(DiagConstexpr);
+  if (FD->isConsteval())
+    DiagInvalid(DiagConsteval);
   // [dcl.spec.auto]p15: "A function declared with a return type that uses a
   // placeholder type shall not be a coroutine."
   if (FD->getReturnType()->isUndeducedType())
     DiagInvalid(DiagAutoRet);
   // [dcl.fct.def.coroutine]p1: "The parameter-declaration-clause of the
   // coroutine shall not terminate with an ellipsis that is not part of a
   // parameter-declaration."
   if (FD->isVariadic())

clang/lib/Sema/SemaDecl.cpp

if (DS.isInlineSpecified())
     Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
         << getLangOpts().CPlusPlus17;
 
   if (DS.isConstexprSpecified()) {
     // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
     // and definitions of functions and variables.
     if (Tag)
       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
           << GetDiagnosticTypeSpecifierID(DS.getTypeSpecType());
     else
       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
     // Don't emit warnings after this error.
     return TagD;
   }
 
   DiagnoseFunctionSpecifiers(DS);
 
if (D.getDeclSpec().isConstexprSpecified()) {
       NewVD->setConstexpr(true);
       // C++1z [dcl.spec.constexpr]p1:
       //   A static data member declared with the constexpr specifier is
       //   implicitly an inline variable.
       if (NewVD->isStaticDataMember() && getLangOpts().CPlusPlus17)
         NewVD->setImplicitlyInline();
     }
   }
 
   if (D.getDeclSpec().isInlineSpecified()) {
     if (!getLangOpts().CPlusPlus) {
       Diag(D.getDeclSpec().getInlineSpecLoc(), diag::err_inline_non_function)
           << 0;
     } else if (CurContext->isFunctionOrMethod()) {
       // 'inline' is not allowed on block scope variable declaration.
       Diag(D.getDeclSpec().getInlineSpecLoc(),
            diag::err_inline_declaration_block_scope) << Name
if (!SemaRef.getLangOpts().CPlusPlus) {
     if (D.isInvalidType())
       NewFD->setInvalidDecl();
 
     return NewFD;
   }
 
   ExplicitSpecifier ExplicitSpecifier = D.getDeclSpec().getExplicitSpecifier();
   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+  bool isConsteval = D.getDeclSpec().isConstevalSpecified();
 
   // Check that the return type is not an abstract class type.
   // For record types, this is done by the AbstractClassUsageDiagnoser once
   // the class has been completely parsed.
   if (!DC->isRecord() &&
       SemaRef.RequireNonAbstractType(
           D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
           diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
     D.setInvalidType();
 
   if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
     // This is a C++ constructor declaration.
     assert(DC->isRecord() &&
            "Constructors can only be declared in a member context");
 
     R = SemaRef.CheckConstructorDeclarator(D, R, SC);
     return CXXConstructorDecl::Create(
         SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
         TInfo, ExplicitSpecifier, isInline,
-        /*isImplicitlyDeclared=*/false, isConstexpr);
+        /*isImplicitlyDeclared=*/false, isConstexpr, isConsteval);
 
   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
     // This is a C++ destructor declaration.
     if (DC->isRecord()) {
       R = SemaRef.CheckDestructorDeclarator(D, R, SC);
       CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
       CXXDestructorDecl *NewDD =
           CXXDestructorDecl::Create(SemaRef.Context, Record, D.getBeginLoc(),
if (DC->isRecord()) {
       return NewDD;
 
     } else {
       SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
       D.setInvalidType();
 
       // Create a FunctionDecl to satisfy the function definition parsing
       // code path.
-      return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
-                                  D.getIdentifierLoc(), Name, R, TInfo, SC,
-                                  isInline,
-                                  /*hasPrototype=*/true, isConstexpr);
+      return FunctionDecl::Create(
+          SemaRef.Context, DC, D.getBeginLoc(), D.getIdentifierLoc(), Name, R,
+          TInfo, SC, isInline,
+          /*hasPrototype=*/true, isConstexpr, isConsteval);
     }
 
   } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
     if (!DC->isRecord()) {
       SemaRef.Diag(D.getIdentifierLoc(),
            diag::err_conv_function_not_member);
       return nullptr;
     }
 
     SemaRef.CheckConversionDeclarator(D, R, SC);
     IsVirtualOkay = true;
-    return CXXConversionDecl::Create(
-        SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
-        TInfo, isInline, ExplicitSpecifier, isConstexpr, SourceLocation());
+    return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
+                                     D.getBeginLoc(), NameInfo, R, TInfo,
+                                     isInline, ExplicitSpecifier, isConstexpr,
+                                     isConsteval, SourceLocation());
 
   } else if (Name.getNameKind() == DeclarationName::CXXDeductionGuideName) {
     SemaRef.CheckDeductionGuideDeclarator(D, R, SC);
 
     return CXXDeductionGuideDecl::Create(SemaRef.Context, DC, D.getBeginLoc(),
                                          ExplicitSpecifier, NameInfo, R, TInfo,
                                          D.getEndLoc());
   } else if (DC->isRecord()) {
     // If the name of the function is the same as the name of the record,
     // then this must be an invalid constructor that has a return type.
     // (The parser checks for a return type and makes the declarator a
     // constructor if it has no return type).
     if (Name.getAsIdentifierInfo() &&
         Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
       SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
         << SourceRange(D.getIdentifierLoc());
       return nullptr;
     }
 
     // This is a C++ method declaration.
     CXXMethodDecl *Ret = CXXMethodDecl::Create(
         SemaRef.Context, cast<CXXRecordDecl>(DC), D.getBeginLoc(), NameInfo, R,
-        TInfo, SC, isInline, isConstexpr, SourceLocation());
+        TInfo, SC, isInline, isConstexpr, isConsteval, SourceLocation());
     IsVirtualOkay = !Ret->isStatic();
     return Ret;
   } else {
     bool isFriend =
         SemaRef.getLangOpts().CPlusPlus && D.getDeclSpec().isFriendSpecified();
     if (!isFriend && SemaRef.CurContext->isRecord())
       return nullptr;
 
     // Determine whether the function was written with a
     // prototype. This true when:
     //   - we're in C++ (where every function has a prototype),
     return FunctionDecl::Create(SemaRef.Context, DC, D.getBeginLoc(), NameInfo,
                                 R, TInfo, SC, isInline, true /*HasPrototype*/,
-                                isConstexpr);
+                                isConstexpr, isConsteval);
   }
 }
 
 enum OpenCLParamType {
   ValidKernelParam,
   PtrPtrKernelParam,
   PtrKernelParam,
   InvalidAddrSpacePtrKernelParam,
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
   if (IsLocalExternDecl)
     NewFD->setLocalExternDecl();
 
   if (getLangOpts().CPlusPlus) {
     bool isInline = D.getDeclSpec().isInlineSpecified();
     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
     bool hasExplicit = D.getDeclSpec().hasExplicitSpecifier();
     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
+    bool isConsteval = D.getDeclSpec().isConstevalSpecified();
     isFriend = D.getDeclSpec().isFriendSpecified();
     if (isFriend && !isInline && D.isFunctionDefinition()) {
       // C++ [class.friend]p5
       //   A function can be defined in a friend declaration of a
       //   class . . . . Such a function is implicitly inline.
       NewFD->setImplicitlyInline();
     }
 
if (hasExplicit && !NewFD->isInvalidDecl() &&
         // 'explicit' was specified on a function that wasn't a constructor
         // or conversion function.
         Diag(D.getDeclSpec().getExplicitSpecLoc(),
              diag::err_explicit_non_ctor_or_conv_function)
             << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecRange());
       }
     }
 
-    if (isConstexpr) {
-      // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
-      // are implicitly inline.
+    if (isConstexpr || isConsteval) {
+      // C++2a [dcl.constexpr]p1: A function or static data member declared with
+      // the constexpr or consteval specifier is implicitly an inline function
+      // or variable ([dcl.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);
+      // C++2a [dcl.constexpr]p2: A destructor, an allocation function, or a
+      // deallocation function shall not be declared with the consteval
+      // specifier.
+      if (isa<CXXDestructorDecl>(NewFD)) {
+        if (isConstexpr)
+          Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor)
+              << "constexpr";
+        if (isConsteval)
+          Diag(D.getDeclSpec().getConstevalSpecLoc(), diag::err_constexpr_dtor)
+              << "consteval";
+      }
+      if (isConsteval) {
+        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().getConstevalSpecLoc(),
+                 diag::err_invalid_consteval_decl_kind)
+                << MD->getOverloadedOperator() - OO_New;
+            NewFD->setConsteval(false);
+            NewFD->setConstexpr(true);
+          }
+        }
+      }
     }
 
     // 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)
enum DoesntSupport {
     FuncTemplates = 0,
     VirtFuncs = 1,
     DeducedReturn = 2,
     Constructors = 3,
     Destructors = 4,
     DeletedFuncs = 5,
     DefaultedFuncs = 6,
     ConstexprFuncs = 7,
+    ConstevalFuncs = 8,
   };
   enum Different {
     CallingConv = 0,
     ReturnType = 1,
     ConstexprSpec = 2,
     InlineSpec = 3,
     StorageClass = 4,
-    Linkage = 5
+    Linkage = 5,
+    ConstevalSpec = 6
   };
 
   bool IsCPUSpecificCPUDispatchMVType =
       MVType == MultiVersionKind::CPUDispatch ||
       MVType == MultiVersionKind::CPUSpecific;
 
   if (OldFD && !OldFD->getType()->getAs<FunctionProtoType>()) {
     S.Diag(OldFD->getLocation(), diag::err_multiversion_noproto);
static bool CheckMultiVersionAdditionalRules(Sema &S, const FunctionDecl *OldFD,
   if (NewFD->isDeleted())
     return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
            << IsCPUSpecificCPUDispatchMVType << DeletedFuncs;
 
   if (NewFD->isDefaulted())
     return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
            << IsCPUSpecificCPUDispatchMVType << DefaultedFuncs;
 
-  if (NewFD->isConstexpr() && (MVType == MultiVersionKind::CPUDispatch ||
-                               MVType == MultiVersionKind::CPUSpecific))
+  if (MVType == MultiVersionKind::CPUDispatch ||
+      MVType == MultiVersionKind::CPUSpecific) {
+    if (NewFD->isConstexpr())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
              << IsCPUSpecificCPUDispatchMVType << ConstexprFuncs;
+    if (NewFD->isConsteval())
+      return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
+             << IsCPUSpecificCPUDispatchMVType << ConstevalFuncs;
+  }
 
   QualType NewQType = S.getASTContext().getCanonicalType(NewFD->getType());
   const auto *NewType = cast<FunctionType>(NewQType);
   QualType NewReturnType = NewType->getReturnType();
 
   if (NewReturnType->isUndeducedType())
     return S.Diag(NewFD->getLocation(), diag::err_multiversion_doesnt_support)
            << IsCPUSpecificCPUDispatchMVType << DeducedReturn;
if (OldFD) {
     if (OldReturnType != NewReturnType)
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << ReturnType;
 
     if (OldFD->isConstexpr() != NewFD->isConstexpr())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << ConstexprSpec;
 
+    if (OldFD->isConsteval() != NewFD->isConsteval())
+      return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
+             << ConstevalSpec;
+
     if (OldFD->isInlineSpecified() != NewFD->isInlineSpecified())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << InlineSpec;
 
     if (OldFD->getStorageClass() != NewFD->getStorageClass())
       return S.Diag(NewFD->getLocation(), diag::err_multiversion_diff)
              << StorageClass;
 
if (DS.isNoreturnSpecified()) {
     SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
     SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
     Diag(NoreturnLoc, diag::ext_noreturn_main);
     Diag(NoreturnLoc, diag::note_main_remove_noreturn)
       << FixItHint::CreateRemoval(NoreturnRange);
   }
   if (FD->isConstexpr()) {
     Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
-      << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
+        << 0 << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
     FD->setConstexpr(false);
   }
+  if (FD->isConsteval()) {
+    Diag(DS.getConstevalSpecLoc(), diag::err_constexpr_main)
+        << 1 << FixItHint::CreateRemoval(DS.getConstevalSpecLoc());
+    FD->setConsteval(false);
+  }
 
   if (getLangOpts().OpenCL) {
     Diag(FD->getLocation(), diag::err_opencl_no_main)
         << FD->hasAttr<OpenCLKernelAttr>();
     FD->setInvalidDecl();
     return;
   }
 

 
 bool Sema::canSkipFunctionBody(Decl *D) {
   // We cannot skip the body of a function (or function template) which is
   // constexpr, since we may need to evaluate its body in order to parse the
   // rest of the file.
   // We cannot skip the body of a function with an undeduced return type,
   // because any callers of that function need to know the type.
   if (const FunctionDecl *FD = D->getAsFunction()) {
-    if (FD->isConstexpr())
+    if (FD->isConstexprOrConsteval())
       return false;
     // We can't simply call Type::isUndeducedType here, because inside template
     // auto can be deduced to a dependent type, which is not considered
     // "undeduced".
     if (FD->getReturnType()->getContainedDeducedType())
       return false;
   }
   return Consumer.shouldSkipFunctionBody(D);
if (Body && (!FD || !FD->isDefaulted())) {
     }
     if (!getDiagnostics().hasUncompilableErrorOccurred() &&
         !isa<FunctionTemplateDecl>(dcl)) {
       // Since the body is valid, issue any analysis-based warnings that are
       // enabled.
       ActivePolicy = &WP;
     }
 
-    if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
+    if (!IsInstantiation && FD && FD->isConstexprOrConsteval() &&
+        !FD->isInvalidDecl() &&
         (!CheckConstexprFunctionDecl(FD) ||
          !CheckConstexprFunctionBody(FD, Body)))
       FD->setInvalidDecl();
 
     if (FD && FD->hasAttr<NakedAttr>()) {
       for (const Stmt *S : Body->children()) {
         // Allow local register variables without initializer as they don't
         // require prologue.

clang/lib/Sema/SemaDeclCXX.cpp

if (NewSM != OldSM) {
       assert(NewParam->hasDefaultArg());
       Diag(NewParam->getLocation(), diag::err_default_arg_makes_ctor_special)
         << NewParam->getDefaultArgRange() << NewSM;
       Diag(Old->getLocation(), diag::note_previous_declaration);
     }
   }
 
   const FunctionDecl *Def;
-  // C++11 [dcl.constexpr]p1: If any declaration of a function or function
-  // template has a constexpr specifier then all its declarations shall
-  // contain the constexpr specifier.
+  // C++2a [dcl.constexpr]p1: If any declaration of a function or function
+  // template has a constexpr or consteval specifier, then all its declarations
+  // shall contain the same specifier.
   if (New->isConstexpr() != Old->isConstexpr()) {
     Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
-      << New << New->isConstexpr();
+        << New << New->isConstexpr() << "constexpr";
+    Diag(Old->getLocation(), diag::note_previous_declaration);
+    Invalid = true;
+  } else if (New->isConsteval() != Old->isConsteval()) {
+    Diag(New->getLocation(), diag::err_constexpr_redecl_mismatch)
+        << New << New->isConsteval() << "consteval";
     Diag(Old->getLocation(), diag::note_previous_declaration);
     Invalid = true;
   } else if (!Old->getMostRecentDecl()->isInlined() && New->isInlined() &&
              Old->isDefined(Def) &&
              // If a friend function is inlined but does not have 'inline'
              // specifier, it is a definition. Do not report attribute conflict
              // in this case, redefinition will be diagnosed later.
              (New->isInlineSpecified() ||
               New->getFriendObjectKind() == Decl::FOK_None)) {
if (isa<CXXTryStmt>(Body)) {
     // - its function-body shall not be a function-try-block;
     //
     // This restriction is lifted in C++2a, as long as inner statements also
     // apply the general constexpr rules.
     Diag(Body->getBeginLoc(),
          !getLangOpts().CPlusPlus2a
              ? diag::ext_constexpr_function_try_block_cxx2a
              : diag::warn_cxx17_compat_constexpr_function_try_block)
-        << isa<CXXConstructorDecl>(Dcl);
+        << isa<CXXConstructorDecl>(Dcl) << Dcl->isConsteval();
   }
 
   // - its function-body shall be [...] a compound-statement that contains only
   //   [... list of cases ...]
   //
   // Note that walking the children here is enough to properly check for
   // CompoundStmt and CXXTryStmt body.
   SourceLocation Cxx1yLoc, Cxx2aLoc;
specialMemberIsConstexpr(Sema &S, CXXRecordDecl *ClassDecl,
                          Sema::InheritedConstructorInfo *Inherited = nullptr) {
   // If we're inheriting a constructor, see if we need to call it for this base
   // class.
   if (InheritedCtor) {
     assert(CSM == Sema::CXXDefaultConstructor);
     auto BaseCtor =
         Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;
     if (BaseCtor)
-      return BaseCtor->isConstexpr();
+      return BaseCtor->isConstexprOrConsteval();
   }
 
   if (CSM == Sema::CXXDefaultConstructor)
     return ClassDecl->hasConstexprDefaultConstructor();
 
   Sema::SpecialMemberOverloadResult SMOR =
       lookupCallFromSpecialMember(S, ClassDecl, CSM, Quals, ConstRHS);
   if (!SMOR.getMethod())
     // A constructor we wouldn't select can't be "involved in initializing"
     // anything.
     return true;
-  return SMOR.getMethod()->isConstexpr();
+  return SMOR.getMethod()->isConstexprOrConsteval();
 }
 
 /// Determine whether the specified special member function would be constexpr
 /// if it were implicitly defined.
 static bool defaultedSpecialMemberIsConstexpr(
     Sema &S, CXXRecordDecl *ClassDecl, Sema::CXXSpecialMember CSM,
     bool ConstArg, CXXConstructorDecl *InheritedCtor = nullptr,
     Sema::InheritedConstructorInfo *Inherited = nullptr) {
void Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD) {
   } else if (ExpectedParams) {
     // A copy assignment operator can take its argument by value, but a
     // defaulted one cannot.
     assert(CSM == CXXCopyAssignment && "unexpected non-ref argument");
     Diag(MD->getLocation(), diag::err_defaulted_copy_assign_not_ref);
     HadError = true;
   }
 
-  // C++11 [dcl.fct.def.default]p2:
-  //   An explicitly-defaulted function may be declared constexpr only if it
-  //   would have been implicitly declared as constexpr,
-  // Do not apply this rule to members of class templates, since core issue 1358
-  // makes such functions always instantiate to constexpr functions. For
-  // functions which cannot be constexpr (for non-constructors in C++11 and for
-  // destructors in C++1y), this is checked elsewhere.
-  //
+  // C++2a [dcl.fct.def.default]p3:
+  // An explicitly-defaulted function that is not defined as deleted may be
+  // declared constexpr or consteval only if it would have been implicitly
+  // declared as constexpr.
+  // Do not apply this rule to members of class
+  // templates, since core issue 1358 makes such functions always instantiate to
+  // constexpr functions. For functions which cannot be constexpr (for
+  // non-constructors in C++11 and for destructors in C++1y), this is checked
+  // elsewhere.
   // FIXME: This should not apply if the member is deleted.
   bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, RD, CSM,
                                                      HasConstParam);
   if ((getLangOpts().CPlusPlus14 ? !isa<CXXDestructorDecl>(MD)
                                  : isa<CXXConstructorDecl>(MD)) &&
-      MD->isConstexpr() && !Constexpr &&
+      MD->isConstexprOrConsteval() && !Constexpr &&
       MD->getTemplatedKind() == FunctionDecl::TK_NonTemplate) {
     Diag(MD->getBeginLoc(), diag::err_incorrect_defaulted_constexpr) << CSM;
     // FIXME: Explain why the special member can't be constexpr.
     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
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(),
-      /*isInline=*/true, /*isImplicitlyDeclared=*/true, Constexpr);
+      /*isInline=*/true, /*isImplicitlyDeclared=*/true, Constexpr,
+      /*isConsteval=*/false);
   DefaultCon->setAccess(AS_public);
   DefaultCon->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXDefaultConstructor,
                                             DefaultCon,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);
bool Constexpr =
       BaseCtor->isConstexpr() &&
       defaultedSpecialMemberIsConstexpr(*this, Derived, CXXDefaultConstructor,
                                         false, BaseCtor, &ICI);
 
   CXXConstructorDecl *DerivedCtor = CXXConstructorDecl::Create(
       Context, Derived, UsingLoc, NameInfo, TInfo->getType(), TInfo,
       BaseCtor->getExplicitSpecifier(), /*Inline=*/true,
       /*ImplicitlyDeclared=*/true, Constexpr,
-      InheritedConstructor(Shadow, BaseCtor));
+      /*isConsteval=*/false, InheritedConstructor(Shadow, BaseCtor));
   if (Shadow->isInvalidDecl())
     DerivedCtor->setInvalidDecl();
 
   // Build an unevaluated exception specification for this fake constructor.
   const FunctionProtoType *FPT = TInfo->getType()->castAs<FunctionProtoType>();
   FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
   EPI.ExceptionSpec.Type = EST_Unevaluated;
   EPI.ExceptionSpec.SourceDecl = DerivedCtor;
bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                      CXXCopyAssignment,
                                                      Const);
 
   //   An implicitly-declared copy assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *CopyAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *CopyAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*isInline=*/true, Constexpr, /*isConsteval=*/false, SourceLocation());
   CopyAssignment->setAccess(AS_public);
   CopyAssignment->setDefaulted();
   CopyAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyAssignment,
                                             CopyAssignment,
                                             /* ConstRHS */ Const,
bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
                                                      CXXMoveAssignment,
                                                      false);
 
   //   An implicitly-declared move assignment operator is an inline public
   //   member of its class.
   DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
   SourceLocation ClassLoc = ClassDecl->getLocation();
   DeclarationNameInfo NameInfo(Name, ClassLoc);
-  CXXMethodDecl *MoveAssignment =
-      CXXMethodDecl::Create(Context, ClassDecl, ClassLoc, NameInfo, QualType(),
-                            /*TInfo=*/nullptr, /*StorageClass=*/SC_None,
-                            /*isInline=*/true, Constexpr, SourceLocation());
+  CXXMethodDecl *MoveAssignment = CXXMethodDecl::Create(
+      Context, ClassDecl, ClassLoc, NameInfo, QualType(),
+      /*isInline=*/true, Constexpr, /*isConsteval=*/false, SourceLocation());
   MoveAssignment->setAccess(AS_public);
   MoveAssignment->setDefaulted();
   MoveAssignment->setImplicit();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveAssignment,
                                             MoveAssignment,
                                             /* ConstRHS */ false,
CXXConstructorDecl *Sema::DeclareImplicitCopyConstructor(
   DeclarationNameInfo NameInfo(Name, ClassLoc);
 
   //   An implicitly-declared copy constructor is an inline public
   //   member of its class.
   CXXConstructorDecl *CopyConstructor = CXXConstructorDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
       ExplicitSpecifier(),
       /*isInline=*/true,
-      /*isImplicitlyDeclared=*/true, Constexpr);
+      /*isImplicitlyDeclared=*/true, Constexpr,
+      /*isConsteval=*/false);
   CopyConstructor->setAccess(AS_public);
   CopyConstructor->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXCopyConstructor,
                                             CopyConstructor,
                                             /* ConstRHS */ Const,
                                             /* Diagnose */ false);
CXXConstructorDecl *Sema::DeclareImplicitMoveConstructor(
 
   // C++11 [class.copy]p11:
   //   An implicitly-declared copy/move constructor is an inline public
   //   member of its class.
   CXXConstructorDecl *MoveConstructor = CXXConstructorDecl::Create(
       Context, ClassDecl, ClassLoc, NameInfo, QualType(), /*TInfo=*/nullptr,
       ExplicitSpecifier(),
       /*isInline=*/true,
-      /*isImplicitlyDeclared=*/true, Constexpr);
+      /*isImplicitlyDeclared=*/true, Constexpr, /*isConsteval=*/false);
   MoveConstructor->setAccess(AS_public);
   MoveConstructor->setDefaulted();
 
   if (getLangOpts().CUDA) {
     inferCUDATargetForImplicitSpecialMember(ClassDecl, CXXMoveConstructor,
                                             MoveConstructor,
                                             /* ConstRHS */ false,
                                             /* Diagnose */ false);
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();
 
+  if (CheckInvalidConstevalCall(Constructor, ConstructLoc, ExprArgs))
+    return ExprError();
+
   return CXXConstructExpr::Create(
       Context, DeclInitType, ConstructLoc, Constructor, Elidable,
       ExprArgs, HadMultipleCandidates, IsListInitialization,
       IsStdInitListInitialization, RequiresZeroInit,
       static_cast<CXXConstructExpr::ConstructionKind>(ConstructKind),
       ParenRange);
 }
 

clang/lib/Sema/SemaExpr.cpp

ExprResult Sema::DefaultFunctionArrayConversion(Expr *E, bool Diagnose) {
   assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type");
 
   if (Ty->isFunctionType()) {
     if (auto *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
       if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
         if (!checkAddressOfFunctionIsAvailable(FD, Diagnose, E->getExprLoc()))
           return ExprError();
 
-    E = ImpCastExprToType(E, Context.getPointerType(Ty),
-                          CK_FunctionToPointerDecay).get();
+    return ImpCastExprToType(E, Context.getPointerType(Ty),
+                             CK_FunctionToPointerDecay);
   } else if (Ty->isArrayType()) {
     // In C90 mode, arrays only promote to pointers if the array expression is
     // an lvalue.  The relevant legalese is C90 6.2.2.1p3: "an lvalue that has
     // type 'array of type' is converted to an expression that has type 'pointer
     // to type'...".  In C99 this was changed to: C99 6.3.2.1p3: "an expression
     // that has type 'array of type' ...".  The relevant change is "an lvalue"
     // (C90) to "an expression" (C99).
     //
     // C++ 4.2p1:
     // An lvalue or rvalue of type "array of N T" or "array of unknown bound of
     // T" can be converted to an rvalue of type "pointer to T".
     //
     if (getLangOpts().C99 || getLangOpts().CPlusPlus || E->isLValue())
-      E = ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
-                            CK_ArrayToPointerDecay).get();
+      return ImpCastExprToType(E, Context.getArrayDecayedType(Ty),
+                               CK_ArrayToPointerDecay);
   }
   return E;
 }
 
 static void CheckForNullPointerDereference(Sema &S, Expr *E) {
   // Check to see if we are dereferencing a null pointer.  If so,
   // and if not volatile-qualified, this is undefined behavior that the
   // optimizer will delete, so warn about it.  People sometimes try to use this

 /// performed on a function designator of a call expression.
 ExprResult Sema::CallExprUnaryConversions(Expr *E) {
   QualType Ty = E->getType();
   ExprResult Res = E;
   // Only do implicit cast for a function type, but not for a pointer
   // to function type.
   if (Ty->isFunctionType()) {
     Res = ImpCastExprToType(E, Context.getPointerType(Ty),
-                            CK_FunctionToPointerDecay).get();
+                            CK_FunctionToPointerDecay, VK_RValue, nullptr,
+                            CCK_ImplicitConversion,
+                            /*isCastForCall*/ true)
+              .get();
     if (Res.isInvalid())
       return ExprError();
   }
   Res = DefaultLvalueConversion(Res.get());
   if (Res.isInvalid())
     return ExprError();
   return Res.get();
 }

 ExprResult Sema::ActOnConvertVectorExpr(Expr *E, ParsedType ParsedDestTy,
                                         SourceLocation BuiltinLoc,
                                         SourceLocation RParenLoc) {
   TypeSourceInfo *TInfo;
   GetTypeFromParser(ParsedDestTy, &TInfo);
   return SemaConvertVectorExpr(E, TInfo, BuiltinLoc, RParenLoc);
 }
 
+bool Sema::CheckInvalidConstevalCall(FunctionDecl *FDecl, SourceLocation Loc,
+                                     ArrayRef<Expr *> Args, Expr *This) {
+  bool Failed = false;
+  if (FDecl && FDecl->isConsteval() &&
+      (!getCurFunctionDecl() || !getCurFunctionDecl()->isConsteval())) {
+
+    SmallVector<PartialDiagnosticAt, 8> Diags;
+    auto Check = [&](Expr *Arg, unsigned int DiagID, int Index = 0) {
+      Expr::EvalResult Result;
+      Result.Diag = &Diags;
+      if (!Arg->EvaluateAsRValue(Result, getASTContext(), true)) {
+        if (!Failed) {
+          Failed = true;
+          const char *DeclName =
+              (isa<CXXConstructorDecl>(FDecl) ? "consteval constructor"
+                                              : "consteval function");
+          if (FDecl->isOverloadedOperator())
+            DeclName = "consteval operator";
+          Diag(Loc, diag::err_consteval_cannot_be_constant_eval) << DeclName;
+          Diag(FDecl->getLocation(), diag::note_callee_decl) << DeclName;
+        }
+        Diag(Arg->getBeginLoc(), DiagID) << Index;
+        for (const auto &Diag : Diags) {
+          this->Diag(Diag.first, Diag.second);
+        }
+        Diags.clear();
+      }
+    };
+    if (This) {
+      This = This->IgnoreParens();
+      if (auto *MemExpr = dyn_cast<MemberExpr>(This)) {
+        This = nullptr;
+        // the first children of a MemberExpr is the object.
+        if (MemExpr->children().begin() != MemExpr->children().end())
+          // is it possible to have no childrens ?
+          if (*MemExpr->children().begin())
+            // is it possible to have a null childrens ?
+            This = cast<Expr>(*MemExpr->children().begin());
+      }
+
+      if (This) {
+        This = This->IgnoreParenCasts();
+        Check(This, diag::note_not_constexpr_this);
+      }
+    }
+    for (auto It = Args.begin(); It != Args.end(); It++) {
+      Expr *Arg = *It;
+      Check(Arg, diag::note_argument_n_cannot_be_constant_eval,
+            It - Args.begin());
+    }
+  }
+  return Failed;
+}
+
 /// BuildResolvedCallExpr - Build a call to a resolved expression,
 /// i.e. an expression not of \p OverloadTy.  The expression should
 /// unary-convert to an expression of function-pointer or
 /// block-pointer type.
 ///
 /// \param NDecl the declaration being called, if available
 ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
                                        SourceLocation LParenLoc,
ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
   // but can be very challenging to debug.
   if (auto *Caller = getCurFunctionDecl())
     if (Caller->hasAttr<ARMInterruptAttr>()) {
       bool VFP = Context.getTargetInfo().hasFeature("vfp");
       if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>()))
         Diag(Fn->getExprLoc(), diag::warn_arm_interrupt_calling_convention);
     }
 
+  if (CheckInvalidConstevalCall(FDecl, LParenLoc, Args))
+    return ExprError();
+
   // Promote the function operand.
   // We special-case function promotion here because we only allow promoting
   // builtin functions to function pointers in the callee of a call.
   ExprResult Result;
   QualType ResultTy;
   if (BuiltinID &&
       Fn->getType()->isSpecificBuiltinType(BuiltinType::BuiltinFn)) {
     // Extract the return type from the (builtin) function pointer type.
if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
     OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
     if (S && OverOp != OO_None)
       LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(),
                                    Functions);
 
     return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
   }
 
   return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
 }
 
+bool Sema::CheckInvalidConstevalTakeAddress(Expr *Input) {
+  if (Input) {
+    if (auto *DeclRef = dyn_cast<DeclRefExpr>(Input->IgnoreParens())) {
+      if (auto *Function = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
+        if (Function->isConsteval()) {
+          const char *DeclName = Function->isOverloadedOperator()
+                                     ? "consteval operator"
+                                     : "consteval function";
+          Diag(DeclRef->getExprLoc(), diag::err_take_adress_of_consteval_decl)
+              << DeclName;
+          Diag(Function->getLocation(), diag::note_entity_declared_at)
+              << DeclName;
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
 // Unary Operators.  'Tok' is the token for the operator.
 ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
                               tok::TokenKind Op, Expr *Input) {
-  return BuildUnaryOp(S, OpLoc, ConvertTokenKindToUnaryOpcode(Op), Input);
+  UnaryOperatorKind Opc = ConvertTokenKindToUnaryOpcode(Op);
+  if (Opc == UO_AddrOf && CheckInvalidConstevalTakeAddress(Input))
+    return ExprError();
+  return BuildUnaryOp(S, OpLoc, Opc, Input);
 }
 
 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
 ExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
                                 LabelDecl *TheDecl) {
   TheDecl->markUsed(Context);
   // Create the AST node.  The address of a label always has type 'void*'.
   return new (Context) AddrLabelExpr(OpLoc, LabLoc, TheDecl,
switch (SemaRef.ExprEvalContexts.back().Context) {
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
       return false;
   }
   llvm_unreachable("Invalid context");
 }
 
 static bool isImplicitlyDefinableConstexprFunction(FunctionDecl *Func) {
   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(Func);
-  return Func->isConstexpr() &&
+  return Func->isConstexprOrConsteval() &&
          (Func->isImplicitlyInstantiable() || (MD && !MD->isUserProvided()));
 }
 
 /// Mark a function referenced, and check whether it is odr-used
 /// (C++ [basic.def.odr]p2, C99 6.9p3)
 void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
                                   bool MightBeOdrUse) {
   assert(Func && "No function?");
if (Func->isImplicitlyInstantiable()) {
     } else if (TSK != TSK_ImplicitInstantiation) {
       // Use the point of use as the point of instantiation, instead of the
       // point of explicit instantiation (which we track as the actual point of
       // instantiation). This gives better backtraces in diagnostics.
       PointOfInstantiation = Loc;
     }
 
     if (FirstInstantiation || TSK != TSK_ImplicitInstantiation ||
-        Func->isConstexpr()) {
+        Func->isConstexprOrConsteval()) {
       if (isa<CXXRecordDecl>(Func->getDeclContext()) &&
           cast<CXXRecordDecl>(Func->getDeclContext())->isLocalClass() &&
           CodeSynthesisContexts.size())
         PendingLocalImplicitInstantiations.push_back(
             std::make_pair(Func, PointOfInstantiation));
-      else if (Func->isConstexpr())
+      else if (Func->isConstexprOrConsteval())
         // Do not defer instantiations of constexpr functions, to avoid the
         // expression evaluator needing to call back into Sema if it sees a
         // call to such a function.
         InstantiateFunctionDefinition(PointOfInstantiation, Func);
       else {
         Func->setInstantiationIsPending(true);
         PendingInstantiations.push_back(std::make_pair(Func,
                                                        PointOfInstantiation));

clang/lib/Sema/SemaExprCXX.cpp

case ICK_Function_To_Pointer:
     From = ImpCastExprToType(From, FromType, CK_FunctionToPointerDecay,
                              VK_RValue, /*BasePath=*/nullptr, CCK).get();
     break;
 
   default:
     llvm_unreachable("Improper first standard conversion");
   }
 
+  if (!From)
+    return ExprError();
+
   // Perform the second implicit conversion
   switch (SCS.Second) {
   case ICK_Identity:
     // C++ [except.spec]p5:
     //   [For] assignment to and initialization of pointers to functions,
     //   pointers to member functions, and references to functions: the
     //   target entity shall allow at least the exceptions allowed by the
     //   source value in the assignment or initialization.

clang/lib/Sema/SemaLambda.cpp

Sema::ExpressionEvaluationContextRecord::getMangleNumberingContext(
   return *MangleNumbering;
 }
 
 CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
                                            SourceRange IntroducerRange,
                                            TypeSourceInfo *MethodTypeInfo,
                                            SourceLocation EndLoc,
                                            ArrayRef<ParmVarDecl *> Params,
-                                           const bool IsConstexprSpecified) {
+                                           const bool IsConstexprSpecified,
+                                           const bool IsConstevalSpecified) {
   QualType MethodType = MethodTypeInfo->getType();
   TemplateParameterList *TemplateParams =
             getGenericLambdaTemplateParameterList(getCurLambda(), *this);
   // If a lambda appears in a dependent context or is a generic lambda (has
   // template parameters) and has an 'auto' return type, deduce it to a
   // dependent type.
   if (Class->isDependentContext() || TemplateParams) {
     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
   //   trailing-return-type respectively.
   DeclarationName MethodName
     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
   DeclarationNameLoc MethodNameLoc;
   MethodNameLoc.CXXOperatorName.BeginOpNameLoc
     = IntroducerRange.getBegin().getRawEncoding();
   MethodNameLoc.CXXOperatorName.EndOpNameLoc
     = IntroducerRange.getEnd().getRawEncoding();
-  CXXMethodDecl *Method
-    = CXXMethodDecl::Create(Context, Class, EndLoc,
-                            DeclarationNameInfo(MethodName,
-                                                IntroducerRange.getBegin(),
-                                                MethodNameLoc),
-                            MethodType, MethodTypeInfo,
-                            SC_None,
-                            /*isInline=*/true,
-                            IsConstexprSpecified,
-                            EndLoc);
+  CXXMethodDecl *Method = CXXMethodDecl::Create(
+      Context, Class, EndLoc,
+      DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
+      MethodType, MethodTypeInfo, SC_None,
+      /*isInline=*/true, IsConstexprSpecified, IsConstevalSpecified, EndLoc);
   Method->setAccess(AS_public);
 
   // Temporarily set the lexical declaration context to the current
   // context, so that the Scope stack matches the lexical nesting.
   Method->setLexicalDeclContext(CurContext);
   // Create a function template if we have a template parameter list
   FunctionTemplateDecl *const TemplateMethod = TemplateParams ?
             FunctionTemplateDecl::Create(Context, Class,
if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
       ContainsUnexpandedParameterPack = true;
   }
 
   CXXRecordDecl *Class = createLambdaClosureType(Intro.Range, MethodTyInfo,
                                                  KnownDependent, Intro.Default);
 
   CXXMethodDecl *Method =
       startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,
-                            ParamInfo.getDeclSpec().isConstexprSpecified());
+                            ParamInfo.getDeclSpec().isConstexprSpecified(),
+                            ParamInfo.getDeclSpec().isConstevalSpecified());
   if (ExplicitParams)
     CheckCXXDefaultArguments(Method);
 
   // This represents the function body for the lambda function, check if we
   // have to apply optnone due to a pragma.
   AddRangeBasedOptnone(Method);
 
   // code_seg attribute on lambda apply to the method.
for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I) {
     CallOpConvNameTL.setParam(I, From);
   }
 
   CXXConversionDecl *Conversion = CXXConversionDecl::Create(
       S.Context, Class, Loc,
       DeclarationNameInfo(ConversionName, Loc, ConvNameLoc), ConvTy, ConvTSI,
       /*isInline=*/true, ExplicitSpecifier(),
       /*isConstexpr=*/S.getLangOpts().CPlusPlus17,
-      CallOperator->getBody()->getEndLoc());
+      /*isConsteval=*/false, CallOperator->getBody()->getEndLoc());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
 
   if (Class->isGenericLambda()) {
     // Create a template version of the conversion operator, using the template
     // parameter list of the function call operator.
     FunctionTemplateDecl *TemplateCallOperator =
             CallOperator->getDescribedFunctionTemplate();
static void addFunctionPointerConversion(Sema &S,
   // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
   // trailing return type of the invoker would require a visitor to rebuild
   // the trailing return type and adjusting all back DeclRefExpr's to refer
   // to the new static invoker parameters - not the call operator's.
   CXXMethodDecl *Invoke = CXXMethodDecl::Create(
       S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc),
       InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static,
       /*IsInline=*/true,
-      /*IsConstexpr=*/false, CallOperator->getBody()->getEndLoc());
+      /*IsConstexpr=*/false,
+      /*IsConsteval=*/false, CallOperator->getBody()->getEndLoc());
   for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
     InvokerParams[I]->setOwningFunction(Invoke);
   Invoke->setParams(InvokerParams);
   Invoke->setAccess(AS_private);
   Invoke->setImplicit(true);
   if (Class->isGenericLambda()) {
     FunctionTemplateDecl *TemplateCallOperator =
             CallOperator->getDescribedFunctionTemplate();
DeclarationName Name
     = S.Context.DeclarationNames.getCXXConversionFunctionName(
         S.Context.getCanonicalType(BlockPtrTy));
   DeclarationNameLoc NameLoc;
   NameLoc.NamedType.TInfo = S.Context.getTrivialTypeSourceInfo(BlockPtrTy, Loc);
   CXXConversionDecl *Conversion = CXXConversionDecl::Create(
       S.Context, Class, Loc, DeclarationNameInfo(Name, Loc, NameLoc), ConvTy,
       S.Context.getTrivialTypeSourceInfo(ConvTy, Loc),
       /*isInline=*/true, ExplicitSpecifier(),
-      /*isConstexpr=*/false, CallOperator->getBody()->getEndLoc());
+      /*isConstexpr=*/false, /*isConsteval=*/false,
+      CallOperator->getBody()->getEndLoc());
   Conversion->setAccess(AS_public);
   Conversion->setImplicit(true);
   Class->addDecl(Conversion);
 }
 
 static ExprResult performLambdaVarCaptureInitialization(
     Sema &S, const Capture &Capture, FieldDecl *Field,
     SourceLocation ImplicitCaptureLoc, bool IsImplicitCapture) {
LambdaExpr *Lambda = LambdaExpr::Create(Context, Class, IntroducerRange,
                                           Captures,
                                           ExplicitParams, ExplicitResultType,
                                           CaptureInits, EndLoc,
                                           ContainsUnexpandedParameterPack);
   // If the lambda expression's call operator is not explicitly marked constexpr
   // and we are not in a dependent context, analyze the call operator to infer
   // its constexpr-ness, suppressing diagnostics while doing so.
   if (getLangOpts().CPlusPlus17 && !CallOperator->isInvalidDecl() &&
-      !CallOperator->isConstexpr() &&
+      !CallOperator->isConstexprOrConsteval() &&
       !isa<CoroutineBodyStmt>(CallOperator->getBody()) &&
       !Class->getDeclContext()->isDependentContext()) {
     TentativeAnalysisScope DiagnosticScopeGuard(*this);
     CallOperator->setConstexpr(
         CheckConstexprFunctionDecl(CallOperator) &&
         CheckConstexprFunctionBody(CallOperator, CallOperator->getBody()));
   }
 

clang/lib/Sema/SemaOverload.cpp

if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
     S.ResolveExceptionSpec(Loc, FPT);
   DeclRefExpr *DRE = new (S.Context)
       DeclRefExpr(S.Context, Fn, false, Fn->getType(), VK_LValue, Loc, LocInfo);
   if (HadMultipleCandidates)
     DRE->setHadMultipleCandidates(true);
 
   S.MarkDeclRefReferenced(DRE, Base);
   return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
-                             CK_FunctionToPointerDecay);
+                             CK_FunctionToPointerDecay, VK_RValue, nullptr,
+                             Sema::CCK_ImplicitConversion,
+                             /*isCastForCall*/ true);
 }
 
 static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
                                  bool InOverloadResolution,
                                  StandardConversionSequence &SCS,
                                  bool CStyle,
                                  bool AllowObjCWritebackConversion);
 
if (isa<MemberExpr>(NakedMemExpr)) {
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
                                    RParenLoc);
     }
 
     MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
   }
 
+  if (CheckInvalidConstevalCall(Method, LParenLoc, Args, MemExprE))
+    return ExprError();
+
   QualType ResultType = Method->getReturnType();
   ExprValueKind VK = Expr::getValueKindForType(ResultType);
   ResultType = ResultType.getNonLValueExprType(Context);
 
   assert(Method && "Member call to something that isn't a method?");
   const auto *Proto = Method->getType()->getAs<FunctionProtoType>();
   CXXMemberCallExpr *TheCall =
       CXXMemberCallExpr::Create(Context, MemExprE, Args, ResultType, VK,
Call = ImplicitCastExpr::Create(Context, Call.get()->getType(),
                                     CK_UserDefinedConversion, Call.get(),
                                     nullptr, VK_RValue);
 
     return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
   }
 
   CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
 
+  if (CheckInvalidConstevalCall(Best->Function, LParenLoc, Args, Object.get()))
+    return ExprError();
+
   // We found an overloaded operator(). Build a CXXOperatorCallExpr
   // that calls this method, using Object for the implicit object
   // parameter and passing along the remaining arguments.
   CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
 
   // An error diagnostic has already been printed when parsing the declaration.
   if (Method->isInvalidDecl())
     return ExprError();

clang/lib/Sema/SemaTemplate.cpp

if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(Ovl)) {
         continue;
 
       // When matching a constexpr member function template specialization
       // against the primary template, we don't yet know whether the
       // specialization has an implicit 'const' (because we don't know whether
       // it will be a static member function until we know which template it
       // specializes), so adjust it now assuming it specializes this template.
       QualType FT = FD->getType();
-      if (FD->isConstexpr()) {
+      if (FD->isConstexprOrConsteval()) {
         CXXMethodDecl *OldMD =
           dyn_cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl());
         if (OldMD && OldMD->isConst()) {
           const FunctionProtoType *FPT = FT->castAs<FunctionProtoType>();
           FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
           EPI.TypeQuals.addConst();
           FT = Context.getFunctionType(FPT->getReturnType(),
                                        FPT->getParamTypes(), EPI);
if (TSK == TSK_Undeclared || TSK == TSK_ImplicitInstantiation) {
     Specialization->setLexicalDeclContext(FD->getLexicalDeclContext());
     // C++11 [dcl.constexpr]p1: An explicit specialization of a constexpr
     // function can differ from the template declaration with respect to
     // the constexpr specifier.
     // FIXME: We need an update record for this AST mutation.
     // FIXME: What if there are multiple such prior declarations (for instance,
     // from different modules)?
     Specialization->setConstexpr(FD->isConstexpr());
+    Specialization->setConsteval(FD->isConsteval());
   }
 
   // FIXME: Check if the prior specialization has a point of instantiation.
   // If so, we have run afoul of .
 
   // If this is a friend declaration, then we're not really declaring
   // an explicit specialization.
   bool isFriend = (FD->getFriendObjectKind() != Decl::FOK_None);

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

Function = CXXDeductionGuideDecl::Create(
         D->getSourceRange().getEnd());
     if (DGuide->isCopyDeductionCandidate())
       cast<CXXDeductionGuideDecl>(Function)->setIsCopyDeductionCandidate();
     Function->setAccess(D->getAccess());
   } else {
     Function = FunctionDecl::Create(
         SemaRef.Context, DC, D->getInnerLocStart(), NameInfo, T, TInfo,
         D->getCanonicalDecl()->getStorageClass(), D->isInlineSpecified(),
-        D->hasWrittenPrototype(), D->isConstexpr());
+        D->hasWrittenPrototype(), D->isConstexpr(), D->isConsteval());
     Function->setRangeEnd(D->getSourceRange().getEnd());
   }
 
   if (D->isInlined())
     Function->setImplicitlyInline();
 
   if (QualifierLoc)
     Function->setQualifierInfo(QualifierLoc);
Decl *TemplateDeclInstantiator::VisitCXXMethodDecl(
 
   SourceLocation StartLoc = D->getInnerLocStart();
   DeclarationNameInfo NameInfo
     = SemaRef.SubstDeclarationNameInfo(D->getNameInfo(), TemplateArgs);
   if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
     Method = CXXConstructorDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         InstantiatedExplicitSpecifier, Constructor->isInlineSpecified(), false,
-        Constructor->isConstexpr());
+        Constructor->isConstexpr(), Constructor->isConsteval());
     Method->setRangeEnd(Constructor->getEndLoc());
   } else if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(D)) {
     Method = CXXDestructorDecl::Create(SemaRef.Context, Record,
                                        StartLoc, NameInfo, T, TInfo,
                                        Destructor->isInlineSpecified(),
                                        false);
     Method->setRangeEnd(Destructor->getEndLoc());
   } else if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
     Method = CXXConversionDecl::Create(
         SemaRef.Context, Record, StartLoc, NameInfo, T, TInfo,
         Conversion->isInlineSpecified(), InstantiatedExplicitSpecifier,
-        Conversion->isConstexpr(), Conversion->getEndLoc());
+        Conversion->isConstexpr(), Conversion->isConsteval(),
+        Conversion->getEndLoc());
   } else {
     StorageClass SC = D->isStatic() ? SC_Static : SC_None;
     Method = CXXMethodDecl::Create(SemaRef.Context, Record, StartLoc, NameInfo,
                                    T, TInfo, SC, D->isInlineSpecified(),
-                                   D->isConstexpr(), D->getEndLoc());
+                                   D->isConstexpr(), D->isConsteval(),
+                                   D->getEndLoc());
   }
 
   if (D->isInlined())
     Method->setImplicitlyInline();
 
   if (QualifierLoc)
     Method->setQualifierInfo(QualifierLoc);
 

clang/lib/Sema/TreeTransform.h

= getSema().createLambdaClosureType(E->getIntroducerRange(),
                                         E->getCaptureDefault());
   getDerived().transformedLocalDecl(E->getLambdaClass(), Class);
 
   // Build the call operator.
   CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
       Class, E->getIntroducerRange(), NewCallOpTSI,
       E->getCallOperator()->getEndLoc(),
       NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
-      E->getCallOperator()->isConstexpr());
+      E->getCallOperator()->isConstexpr(), E->getCallOperator()->isConsteval());
 
   LSI->CallOperator = NewCallOperator;
 
   for (unsigned I = 0, NumParams = NewCallOperator->getNumParams();
        I != NumParams; ++I) {
     auto *P = NewCallOperator->getParamDecl(I);
     if (P->hasUninstantiatedDefaultArg()) {
       EnterExpressionEvaluationContext Eval(

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
   FD->setHasWrittenPrototype(Record.readInt());
   FD->setDeletedAsWritten(Record.readInt());
   FD->setTrivial(Record.readInt());
   FD->setTrivialForCall(Record.readInt());
   FD->setDefaulted(Record.readInt());
   FD->setExplicitlyDefaulted(Record.readInt());
   FD->setHasImplicitReturnZero(Record.readInt());
   FD->setConstexpr(Record.readInt());
+  FD->setConsteval(Record.readInt());
   FD->setUsesSEHTry(Record.readInt());
   FD->setHasSkippedBody(Record.readInt());
   FD->setIsMultiVersion(Record.readInt());
   FD->setLateTemplateParsed(Record.readInt());
 
   FD->setCachedLinkage(static_cast<Linkage>(Record.readInt()));
   FD->EndRangeLoc = ReadSourceLocation();
 

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitFunctionDecl(FunctionDecl *D) {
   Record.push_back(D->hasWrittenPrototype());
   Record.push_back(D->isDeletedBit());
   Record.push_back(D->isTrivial());
   Record.push_back(D->isTrivialForCall());
   Record.push_back(D->isDefaulted());
   Record.push_back(D->isExplicitlyDefaulted());
   Record.push_back(D->hasImplicitReturnZero());
   Record.push_back(D->isConstexpr());
+  Record.push_back(D->isConsteval());
   Record.push_back(D->usesSEHTry());
   Record.push_back(D->hasSkippedBody());
   Record.push_back(D->isMultiVersion());
   Record.push_back(D->isLateTemplateParsed());
   Record.push_back(D->getLinkageInternal());
   Record.AddSourceLocation(D->getEndLoc());
 
   Record.push_back(D->getODRHash());
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(1));                         // HasWrittenProto
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Deleted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Trivial
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // TrivialForCall
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Defaulted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ExplicitlyDefaulted
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ImplicitReturnZero
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constexpr
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Consteval
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // UsesSEHTry
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // SkippedBody
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // MultiVersion
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // LateParsed
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // Linkage
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // LocEnd
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // ODRHash
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // TemplateKind

clang/test/SemaCXX/cxx2a-compat.cpp

 // expected-error@-8 {{does not refer to a value}}
 // expected-error@-9 {{expected member name or ';'}}
 // expected-error@-10 {{expected ')'}}
 // expected-note@-12 {{declared here}}
 // expected-note@-12 {{to match this '('}}
 #if !defined(__cpp_conditional_explicit) || __cpp_conditional_explicit != 201806L
 #error "the feature test macro __cpp_conditional_explicit isn't correct"
 #endif
+#endif
+
+auto l = []() consteval {};
+int consteval();
+#if __cplusplus <= 201703L
+// expected-warning@-3 {{'consteval' is a keyword in C++2a}}
+#else
+// expected-error@-4 {{expected unqualified-id}}
 #endif
 No newline at end of file

clang/test/SemaCXX/cxx2a-consteval.cpp

+// RUN: %clang_cc1 -std=c++2a -fsyntax-only %s -verify
+
+int i_global; // expected-note+ {{declared here}}
+extern int i_extern; // expected-note+ {{declared here}}
+const int i_const = 0;
+constexpr int i_constexpr = 0;
+
+consteval int f_eval(int i) {
+// expected-note@-1+ {{consteval function declared here}}
+  return i;
+}
+
+constexpr auto l_eval = [](int i) consteval {
+// expected-note@-1+ {{consteval operator declared here}}
+  return i;
+};
+
+constexpr int f_expr(int i) {
+  return i;
+}
+
+struct A {
+  consteval int f_eval(int i) const {
+// expected-note@-1+ {{consteval function declared here}}
+    return i;
+  }
+};
+
+constexpr A a;
+
+namespace invalid_call_args {
+
+int d0 = f_eval(0);
+int l0 = l_eval(0);
+int m0 = a.f_eval(0);
+int d2 = f_eval(i_extern);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int l2 = l_eval(i_extern);
+// expected-error@-1 {{call to consteval operator cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int m2 = a.f_eval(i_extern);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int d4 = f_eval(i_const);
+int l4 = l_eval(i_const);
+int m4 = a.f_eval(i_const);
+int d6 = f_eval(i_constexpr);
+int l6 = l_eval(i_constexpr);
+int m6 = a.f_eval(i_constexpr);
+int d8 = f_eval(i_global);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int l8 = l_eval(i_global);
+// expected-error@-1 {{call to consteval operator cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int m8 = a.f_eval(i_global);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{argument 0 cannot be constant evaluated}}
+// expected-note@-3 {{not allowed in a constant expression}}
+
+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 {{call to consteval function cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  // expected-error@-4 {{variables defined in a constexpr function must be initialized}}
+  // TODO: prevent the error from the previous line from being emitted.
+  int l2 = l_eval(i);
+  // expected-error@-1 {{call to consteval operator cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  int m2 = a.f_eval(i);
+  // expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  int d4 = f_eval(i_const);
+  int l4 = l_eval(i_const);
+  int m4 = a.f_eval(i_const);
+  int d6 = f_eval(i_constexpr);
+  int l6 = l_eval(i_constexpr);
+  int m6 = a.f_eval(i_constexpr);
+  int d8 = f_eval(i_global);
+  // expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  int l8 = l_eval(i_global);
+  // expected-error@-1 {{call to consteval operator cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  int m8 = a.f_eval(i_global);
+  // expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+  // expected-note@-2 {{argument 0 cannot be constant evaluated}}
+  // expected-note@-3 {{not allowed in a constant expression}}
+  return 0;
+}
+
+consteval int f2(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int d0 = f_eval(i);
+  int l0 = l_eval(i);
+  int m0 = a.f_eval(i);
+  int d2 = f_eval(i_extern);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+consteval int f3(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int m2 = a.f_eval(i_extern);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+consteval int l3(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int l2 = l_eval(i_extern);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+consteval int f4(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int d4 = f_eval(i_const);
+  int l4 = l_eval(i_const);
+  int m4 = a.f_eval(i_const);
+  int d6 = f_eval(i_constexpr);
+  int l6 = l_eval(i_constexpr);
+  int m6 = a.f_eval(i_constexpr);
+  int d8 = f_eval(i_global);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+consteval int f5(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int l8 = l_eval(i_global);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+consteval int m5(int i) {
+  // expected-error@-1 {{constexpr function never produces a constant expression}}
+  int m8 = a.f_eval(i_global);
+  // expected-note@-1 {{not allowed in a constant expression}}
+  return 0;
+}
+
+consteval int f_multi(int a, int b, int c) {
+// expected-note@-1 {{declared here}}
+  return a + b + c;
+}
+
+int v = f_multi(i_const, i_extern, i_global);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{argument 1 cannot be constant evaluate}}
+// expected-note@-3+ {{not allowed in a constant expression}}
+// expected-note@-4 {{argument 2 cannot be constant evaluate}}
+
+constexpr A a;
+
+A a_dependent;
+// expected-note@-1+ {{declared here}}
+auto l_dependent = [](int i) consteval {
+// expected-note@-1+ {{declared here}}
+  return i;
+};
+
+int i_l = l_dependent(0);
+// expected-error@-1 {{call to consteval operator cannot be constant evaluated}}
+// expected-note@-2 {{call to member of non-constexpr value}}
+// expected-note@-3 {{not allowed in a constant expression}}
+int i_m = a_dependent.f_eval(0);
+// expected-error@-1 {{call to consteval function cannot be constant evaluated}}
+// expected-note@-2 {{call to member of non-constexpr value}}
+// expected-note@-3 {{not allowed in a constant expression}}
+}
+
+namespace taking_address {
+
+using func_type = int(int);
+using mem_ptr_type = int(A::*)(int);
+
+func_type* p1 = (f_eval);
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p2= &(((f_eval)));
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p3 = (func_type*)f_eval;
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p4 = static_cast<func_type*>(f_eval);
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p5 = reinterpret_cast<func_type*>(f_eval);
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p6 = reinterpret_cast<func_type*>(&reinterpret_cast<char>(f_eval));
+// expected-error@-1 {{taking address of a consteval function}}
+func_type* p7 = __builtin_addressof(f_eval);
+// expected-error@-1 {{taking address of a consteval function}}
+
+mem_ptr_type m1 = &A::f_eval;
+// expected-error@-1 {{taking address of a consteval function}}
+auto* l1 = &decltype(l_eval)::operator();
+// expected-error@-1 {{taking address of a consteval operator}}
+
+}
+
+namespace invalid_function {
+using size_t = unsigned long;
+struct A {
+  consteval void *operator new(size_t count);
+  // expected-error@-1 {{operator new cannot be marked consteval}}
+  consteval void *operator new[](size_t count);
+  // expected-error@-1 {{operator new[] cannot be marked consteval}}
+  consteval void operator delete(void* ptr);
+  // expected-error@-1 {{operator delete cannot be marked consteval}}
+  consteval void operator delete[](void* ptr);
+  // expected-error@-1 {{operator delete[] cannot be marked consteval}}
+  consteval ~A();
+  // expected-error@-1 {{destructor cannot be marked consteval}}
+};
+
+}