[clang] Implement if consteval (P1938)

[cor3ntin]

Summary

Modify the IfStmt node to tuppoort constant evaluated expressions.

Add a new ExpressionEvaluationContext::ImmediateFunctionContext to
keep track of immediate function contexts.

This proved easier/better/probably more efficient than
walking the AST backward.
It allows diagnosing nested if consteval statements.

[cor3ntin]

Remove untested clang-format changes

[cor3ntin]

Fix tests formatting

[cor3ntin]

Rebase

[cor3ntin]

Update cxx_status.html

[erichkeane]

clang/include/clang/AST/Stmt.h

167

Not sure how others feel here, but for me, I kinda hate that we're using 'unsigned' bitfields for all of this, particularly because these two are mutually exclusive. I'd prefer (though listen to others here first) if the type of this was something more like:

IfEvalKind EvalKind : 2; // where IfEvalKind is enum class IfEvalKind {None, Constexpr, Consteval};

clang/include/clang/Basic/DiagnosticSemaKinds.td

5946

Oh boy.... this section of 'notes' seem like they deserve some level of merging with a %select. I'd not want anything other than the jump enters controlled statemennt of variants for this patch though.

clang/include/clang/Sema/Sema.h

1316

I get this NOW that I'm looking at it, but isImmediate made me go to assembly-immediate, though perhaps this is only misleading to me. I might bikeshed this to isImmediatelyEvaluated or something.
Anyone else, WDYT?

4719–4720

can this be a scoped enum?

Also, perhaps pulled into the AST in a way that it can be reused for the IfStmt state.

9138

What is our iterator type? I THINK at minimum require this to be auto *

clang/lib/AST/Stmt.cpp

926

Oh dear... I'm not quite sure I want this as a scoped enum.

clang/lib/AST/StmtPrinter.cpp

246

should this be If->getElse?

clang/lib/Parse/ParseStmt.cpp

1364

Is this diag here right? We're in the kw_consteval branch, but it seems we're warning about constexpr-if?

1376

Why is this here instead of with the kw_consteval handling?

clang/lib/Sema/SemaStmt.cpp

883–885

perhaps an assert here: assert((CondExpr || Kind == IfKind_Consteval) && "....")

[cor3ntin]

• Rename isImmediate to isImmediateFunctionContext
• Fix And cleanup Diagnostics in ParseStmt.cpp
• Add assert in SemaStmt.cpp
• Fix StmtPrinter.cpp

[cor3ntin]

clang/include/clang/AST/Stmt.h

167

I was not quite sure where to put an enum I could reuse in different place.
But I think I'd agree with you otherwise.
Any suggestion for where to put it?

clang/include/clang/Sema/Sema.h

9138

The iterator type is ungodly. Likely SmallVector<ExpressionEvaluationContextRecord, 8>::reverse_iterator. I think auto here is more readable but I can change if you want to

clang/lib/Parse/ParseStmt.cpp

1364

Yup, forgot to remove that

1376

To not have a warning when there is an error. Maybe we don't care?
In any case, I've cleanup that

[erichkeane]

Note I didn't have a good chance to re-review this, but wanted to give my feedback to the comments right away.

clang/include/clang/AST/Stmt.h

167

My best suggestion is somewhere in include/Basic.

We don't have a great file I think to fit it, but we DO have a ton where we've created files for smal lthings (see ExceptionSpecificationType.h, Linkage.h, or Lambda.h).

Looking through, there _IS_ a similar enum in Specifiers.h (perhaps the best place for this) that might work well, ConstexprSpecKind might actually just be what we want and could replace the other enum you created later.

clang/include/clang/Sema/Sema.h

9138

I more questioned due to the lack of the *, I see it is the reverse-iterator now, so i don't think that makes it a pointer type, so I don't think it is valuable here. @aaron.ballman is our 'auto nitpicker', so I'll let him to suggest the right answer.

clang/lib/Parse/ParseStmt.cpp

1378

So I still meant here putting it inside the 'if (Tok.is(tok::kw_consteval)' bit, I have a slight preference to match the rest of these sorts of warnings.

[cor3ntin]

use ConstexprSpecKind to describe whether the IfStmt
is constexpr or consteval.
Other minor fixes

[erichkeane]

clang/lib/AST/Stmt.cpp

917

Does this need clang-format again?

926

I see I mistyped here, i'm 'NOW' quite sure. Thanks for fixing it anyway.

clang/lib/AST/StmtPrinter.cpp

239

I think I'm not a fan of the inversion mostly for this, the fact that we end up printing the reverse of what happens in 'if constexpr' is giving me some heartburn.

clang/lib/Analysis/CFG.cpp

3050

I think there is a ternary-confuse-warning in GCC that fires sometimes if you skip outer-parens, you might find it necessary/a good idea to put parens around the condition.

3064–3066

Note for future-reviewer: This ends up being an improvement here, TryResult contains only a single integer in a VERRY bizarre way, it seems to be intended to essentially be a 'true/false/unknown' bit of hackery (despite having 3 states, its an integer?). If someone runs across this comment in the future and wants an 'easy win', I suspect swapping it with a llvm::Optional<bool> or something would be at least an interface-win.

clang/lib/Parse/ParseStmt.cpp

1547

So this is interesting. I'm not sure how I feel about having the AST not represent the textual representation like this. I'm interested what others have to say.

My understanding is that this makes:

if consteval { thenstmt; } else { elsestmt;
be represented as:
IfStmt isConsteval, with getThen()== thenstmt

however
if not consteval { thenstmt; } else { elsestmt;}
be represented as:
IfStmt isConsteval, with getThen()== elsestmt

IMO, this feels too clever.

I think I'd prefer that the IfStmt know whether it is a 'not consteval' and select the right one that way.

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1547

I haven't had the chance to go over this review yet, but this comment caught my eye in my inbox so I figured I'd respond quickly.

The current approach is definitely clever, but I don't think it's the right way to tackle this. Generally, the AST needs to retain enough fidelity to be pretty printed back out to the original source, which wouldn't work here. But also, this makes it harder to write AST matchers over the construct because it's not really matching what the user wrote in source (we sometimes get around this by having a "semantic" and "syntactic" AST representation, but that seems like overkill here).

[cor3ntin]

clang/include/clang/Basic/DiagnosticSemaKinds.td

5946

I don't think we can change that without some more refactor.
see usages of note_protected_by_constexpr_if.
The Diag ID is passed to a GotoScope emitting later. No way to pass parameter. Changing that would be unrelated to this PR

[erichkeane]

clang/include/clang/Basic/DiagnosticSemaKinds.td

5946

good enough for me for now.

[cor3ntin]

clang/lib/Parse/ParseStmt.cpp

1547

This is exactly the wording though.

An if statement of the form if ! consteval compound-statement is not itself a consteval if statement, but is equivalent to the consteval if statement if consteval { } else compound-statement

An if statement of the form `if ! consteval compound-statement1 else statement2` is not itself a consteval if statement, but is equivalent to the consteval if statement

Doing something else would require storing the not position, and I don't think we gain any functionality?

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1547

Sure, the standard also talks about how a for loop is equivalent to a while statement, but we still don't model our AST that way. We gain functionality with the pretty printing facilities actually working and being able to AST match more naturally (like wanting to match a not predicate of an if constexpr statement).

[cor3ntin]

Formatting

[erichkeane]

clang/lib/Parse/ParseStmt.cpp

1547

I don't think you'd necessarily have to store the 'not' position, just the 'not-ness'

[cor3ntin]

Add parens in CFG.cpp

[cor3ntin]

• Add IfStmt::isNegatedConsteval to track whether the if

consteval statement was negated

• Add json/text AST dumps tests

[erichkeane]

So I have some heartburn about IsNegatedConsteval. A part of me wants to suggest ditching the ConstexprKind and creating a new scoped-enum IfStmtKind (perhaps in the same file) that has just None,Constexpr,Consteval,NotConsteval. Its already a bit hinky that we have a value of ConstexprKind that we don't use, so I'm leaning toward it. Other reviewers: WDYT?

Otherwise, I think clang-format REALLY needs a run here, and the codegen test can be fleshed out a bit more. Otherwise, this seems right to me.

clang/include/clang/AST/Stmt.h

1967

Not a fan of making this 'IfConstevalIsNegated' a default here... it means it has to be at the end, where it doesn't particularly make sense. Plus, you have to change all the calls to this function ANYWAY, right?

clang/lib/AST/JSONNodeDumper.cpp

1493

Is the first condition necessary here? I would think isNegatedConsteval should NEVER be true if isConsteval?

clang/lib/AST/StmtPrinter.cpp

242

You had a choice here.... You COULD have blessed the 'c++ operator names', but chose not to. I guess we all have to choose teams:D

clang/test/CodeGenCXX/cxx2b-consteval-if.cpp

2

I tend to like the 'CHECK' lines being inline with the code, it makes it easier to follow in these cases. Additionally, I think the check-lines should be more specific (that they are actually checking for 'call' instructions).

[cor3ntin]

clang/lib/Parse/ParseStmt.cpp

1547

Yep, I realized I need to change.
Oh well.

clang/test/CodeGenCXX/cxx2b-consteval-if.cpp

2

To be honest, I adapted the code from the equivalent test for if constexpr, and I don't actually know how it work

[cor3ntin]

• Use a dedicated enums
• Add more tests
• Improve CodeGen tests

[erichkeane]

A handful of 'nits' (at best), and a wish for the if consteval vs consteval if to be consistent, but otherwise LGTM. Hopefully @aaron.ballman can come and do a final pass.

clang/include/clang/AST/Stmt.h

164–165

2127–2130

Not sure if consteval if follows the same naming convention as constexpr if?

2141

Same change here.

clang/include/clang/Basic/DiagnosticSemaKinds.td

1508

This seems like it needs a newline somewhere/clang-formatting.

1508

1509

5949

I see an inconsistency in a couple of places here between if consteval or consteval if. I THINK it is the latter, so I'm suggesting changes for that. I see the DiagnosticParseKinds seem to use the consteval if spelling, so I feel like perhaps I'm not wrong?

clang/include/clang/Basic/Specifiers.h

32

I'd prefer just reverting the changes to ConstexprSpecKind to the 'before', since you're not using it anymore.

40

45

Reads nicer to me maybe? IDK, feel free to ignore.

clang/include/clang/Sema/Sema.h

1219

[aaron.ballman]

clang/include/clang/AST/Stmt.h

164–165

167

Not sure how others feel here, but for me, I kinda hate that we're using 'unsigned' bitfields for all of this, particularly because these two are mutually exclusive.

Unfortunately I have stronger feelings here. We need the bit-fields to all have the same type, otherwise there's problems with layout in MSVC (also, we often get odd diagnostic behavior we have to come back and fix later, as in https://reviews.llvm.org/rGaf3a4e97d8627a32606ed32001583fe08f15b928). That's why we use unsigned for all our bit-fields.

2081–2105

How do folks feel about this? My concern is that if ! consteval (whatever) is still a consteval if statement, and we care "is this a consteval if statement" more often than we care which form it is, so it's more helpful that isConsteval() returns true for both forms. For the times when we care about negated vs nonnegated, we can use the more explicit functions (which have better parity with their names).

2127–2130

Yup: https://eel.is/c++draft/stmt.if#4.sentence-1

clang/include/clang/Basic/DiagnosticSemaKinds.td

1509

I think the diagnostic group should be named redundant-consteval-if.

clang/include/clang/Basic/Specifiers.h

45

Alternatively, ConstevalNonnegated and ConstevalNegated to make it more clear that they're distinguishable from one another. (I don't feel strongly about any particular opinion here.)

clang/include/clang/Sema/Sema.h

1219

I like the suggestion from @erichkeane, but drop the single quotes as it's no longer talking about syntax at that point.

9138

I'd rewrite to avoid the iterators entirely:

for (const ExpressionEvaluationContextRecord &Rec : llvm::reverse(ExprEvalContexts)) {
  ...
}

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

195

This probably signals that we're missing some test coverage, but this is the first I've heard of this file so I'm not clear on *how* to test it!

clang/lib/AST/JSONNodeDumper.cpp

1493

All three of these are mutually exclusive, so I think it might be better to have: kind = Ordinary | constexpr | consteval | negated consteval as an enumeration rather than having three different fields. WDYT?

clang/lib/AST/StmtPrinter.cpp

246–249

clang/lib/CodeGen/CGStmt.cpp

716–717

clang/lib/Parse/ParseStmt.cpp

1341

This is not the grammar that was adopted and should be updated accordingly. Also, please clearly mark it as C++2b grammar.

1450

This looks incorrect for a consteval if -- that requires parsing a compound statement explicitly, not just any statement.

1521–1526

Oh. I see where the diagnostic is happening. I think it's unclean to parse a statement and then diagnose it later as being the wrong kind of statement -- why not parse the correct kind of statement initially?

clang/lib/Sema/SemaStmt.cpp

930–931

937

Conversions just work this way (http://eel.is/c++draft/conv.integral#2).

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2759

Can you explain these changes? I'm not certain why they were needed.

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp

159

Please add the newline.

[erichkeane]

clang/include/clang/AST/Stmt.h

167

Ah shucks! Thanks for that Aaron! I still like having IfStatementKind for the interface, but it seems like we'll have to static-cast in/out here.

2081–2105

I DO think I like that, the isConstevalorNegatedConsteval was a bit of heartburn running through this, but I couldn't come up with a better spelling. I think this _IS_ that better spelling.

clang/include/clang/Basic/Specifiers.h

45

Mixed with your other suggestion on changing the functions, I think this ends up being a good suggestion.

[cor3ntin]

• Add Bytecode gen tests
• use consteval if consistently
• use isConsteval/isNegatedConsteval/istNonNegatedConsteval
• Address other comments

[cor3ntin]

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

195

Ouch, nasty! I added tests

clang/lib/AST/StmtPrinter.cpp

242

I could have :)
Also, it's easier to see that the ! appertain to consteval

clang/lib/Parse/ParseStmt.cpp

1450

See a little bit below

1521–1526

I think the code reads better that way - we need to parse any kind of statement in other cases. In any case the work is about the same

clang/lib/Sema/SemaStmt.cpp

937

It just seemed more explicit

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2759

I could revert them back actually - I'm just storing the constexpr info after, which seems simpler

[cor3ntin]

use llvm::reverse

[aaron.ballman]

clang/include/clang/AST/Stmt.h

164–165

Looks like this one was missed -- also, this needs to be unsigned instead of using the enum directly (see discussion below).

clang/include/clang/Basic/Specifiers.h

45

Sorry, Erich and I probably made this less clear -- can you go with:

enum class IfStatementKind : unsigned {
  Ordinary,
  Constexpr,
  NonnegatedConsteval,
  NegatedConsteval
};

(or flip the word order to ConstevalNonnegated if you prefer). This keeps it aligned with the names of the functions on IfStmt.

clang/include/clang/Sema/Sema.h

9138

Did this one get missed?

clang/lib/AST/JSONNodeDumper.cpp

1493

After discussing with @cor3ntin off-list, I'm retracting this suggestion -- the OnlyIfTrue bit means this will be mutually exclusive output already.

clang/lib/Parse/ParseStmt.cpp

1341–1342

1521–1526

Hmmm, this makes me a bit uncomfortable, but I'm not convinced it's a problem either. Calling ParseCompoundStmt() would require checking the token first to avoid an assert, so I can understand better wanting to avoid the messier code that comes from that. However, calling the correct parsing method also means that we don't attempt to parse something we shouldn't parse only to reject it much later; I'm a bit concerned that we'll get some bad error recovery when parsing the more general thing. However, my attempts to come up with test cases where this matters are so far falling pretty flat. One test that would help (and should pass still) is:

if consteval ({1;}); // Do we correctly reject the statement expression?

clang/lib/Sema/SemaStmt.cpp

932–934

936–938

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2759

Oh, I see what's going on now. Thanks!

[cor3ntin]

Fix comment

[cor3ntin]

Adress Aaron's comments

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1521–1526

Please hold off on changes here for the moment, as I think I may have identified a DR. Consider code like:

if consteval [[]] {
}

According to the C++ grammar, this construct should not be accepted. However, that's inconsistent with every other form of if statement and seems like a defect to me. I've asked on the Core reflectors to see.

[cor3ntin]

clang/lib/Parse/ParseStmt.cpp

1521–1526

As discussed offline I'm letting this as is so that we can parse attributes

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1521–1526

The sentiment I'm getting from the Core reflectors is that this is an oversight and there's no reason we shouldn't support attributes here.

So I think the current form is good, but I'd like some parsing test coverage for attributes:

// Test in test/Parser/
if consteval [[]] {
} else [[]] {
}

if !consteval [[]] {
} else [[]] {
}

and some AST test coverage that shows we really do attach the attributes to the substatement as expected:

// Test in test/AST/
if consteval [[likely]] {
}

[cor3ntin]

Add support for attributes

[aaron.ballman]

Aside from a nit, I think this is ready to go. Adding Richard in case he has the chance to give this a once-over before it lands.

clang/lib/Parse/ParseStmt.cpp

1522–1526

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp

5

It looks like you dropped the test for GNU statement expressions; can you add that one back (it's helpful to ensure we don't accidentally regress behavior in the future given how closely these relate to compound statements already).

[cor3ntin]

Address nits

[cor3ntin]

Fix compilation

[aaron.ballman]

I've commit on your behalf in 424733c12aacc227a28114deba72061153f8dff2, thank you for the new functionality!

clang/include/clang/AST/Stmt.h

 
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/DependenceFlags.h"
 #include "clang/AST/StmtIterator.h"
 #include "clang/Basic/CapturedStmt.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitmaskEnum.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
protected:
   };
 
   class IfStmtBitfields {
     friend class ASTStmtReader;
     friend class IfStmt;
 
     unsigned : NumStmtBits;
 
-    /// True if this if statement is a constexpr if.
-    unsigned IsConstexpr : 1;
+    /// Whether this is a constexpr if, or a consteval if, or neither.
+    unsigned Kind : 3;
 
     /// True if this if statement has storage for an else statement.
     unsigned HasElse : 1;
 
     /// True if this if statement has storage for a variable declaration.
     unsigned HasVar : 1;
 
     /// True if this if statement has storage for an init statement.
     unsigned HasInit : 1;
 
class IfStmt final
   unsigned varOffset() const { return InitOffset + hasInitStorage(); }
   unsigned condOffset() const {
     return InitOffset + hasInitStorage() + hasVarStorage();
   }
   unsigned thenOffset() const { return condOffset() + ThenOffsetFromCond; }
   unsigned elseOffset() const { return condOffset() + ElseOffsetFromCond; }
 
   /// Build an if/then/else statement.
-  IfStmt(const ASTContext &Ctx, SourceLocation IL, bool IsConstexpr, Stmt *Init,
-         VarDecl *Var, Expr *Cond, SourceLocation LParenLoc,
+  IfStmt(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind,
+         Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LParenLoc,
          SourceLocation RParenLoc, Stmt *Then, SourceLocation EL, Stmt *Else);
 
   /// Build an empty if/then/else statement.
   explicit IfStmt(EmptyShell Empty, bool HasElse, bool HasVar, bool HasInit);
 
 public:
   /// Create an IfStmt.
   static IfStmt *Create(const ASTContext &Ctx, SourceLocation IL,
-                        bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
-                        SourceLocation LPL, SourceLocation RPL, Stmt *Then,
-                        SourceLocation EL = SourceLocation(),
+                        IfStatementKind Kind, Stmt *Init, VarDecl *Var,
+                        Expr *Cond, SourceLocation LPL, SourceLocation RPL,
+                        Stmt *Then, SourceLocation EL = SourceLocation(),
                         Stmt *Else = nullptr);
 
   /// Create an empty IfStmt optionally with storage for an else statement,
   /// condition variable and init expression.
   static IfStmt *CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
                              bool HasInit);
 
   /// True if this IfStmt has the storage for an init statement.
   bool hasInitStorage() const { return IfStmtBits.HasInit; }
public:
   }
 
   void setElseLoc(SourceLocation ElseLoc) {
     assert(hasElseStorage() &&
            "This if statement has no storage for an else statement!");
     *getTrailingObjects<SourceLocation>() = ElseLoc;
   }
 
-  bool isConstexpr() const { return IfStmtBits.IsConstexpr; }
-  void setConstexpr(bool C) { IfStmtBits.IsConstexpr = C; }
+  bool isConsteval() const {
+    return getStatementKind() == IfStatementKind::ConstevalNonNegated ||
+           getStatementKind() == IfStatementKind::ConstevalNegated;
+  }
+
+  bool isNonNegatedConsteval() const {
+    return getStatementKind() == IfStatementKind::ConstevalNonNegated;
+  }
+
+  bool isNegatedConsteval() const {
+    return getStatementKind() == IfStatementKind::ConstevalNegated;
+  }
+
+  bool isConstexpr() const {
+    return getStatementKind() == IfStatementKind::Constexpr;
+  }
+
+  void setStatementKind(IfStatementKind Kind) {
+    IfStmtBits.Kind = static_cast<unsigned>(Kind);
+  }
+
+  IfStatementKind getStatementKind() const {
+    return static_cast<IfStatementKind>(IfStmtBits.Kind);
+  }
 
   /// If this is an 'if constexpr', determine which substatement will be taken.
   /// Otherwise, or if the condition is value-dependent, returns None.
   Optional<const Stmt*> getNondiscardedCase(const ASTContext &Ctx) const;
   Optional<Stmt *> getNondiscardedCase(const ASTContext &Ctx);
 
   bool isObjCAvailabilityCheck() const;
 
   SourceLocation getBeginLoc() const { return getIfLoc(); }
   SourceLocation getEndLoc() const LLVM_READONLY {
     if (getElse())
       return getElse()->getEndLoc();
     return getThen()->getEndLoc();
   }
   SourceLocation getLParenLoc() const { return LParenLoc; }
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
   SourceLocation getRParenLoc() const { return RParenLoc; }
   void setRParenLoc(SourceLocation Loc) { RParenLoc = Loc; }
 
   // Iterators over subexpressions.  The iterators will include iterating
   // over the initialization expression referenced by the condition variable.
   child_range children() {
-    return child_range(getTrailingObjects<Stmt *>(),
+    // We always store a condition, but there is none for consteval if
+    // statements, so skip it.
+    return child_range(getTrailingObjects<Stmt *>() +
+                           (isConsteval() ? thenOffset() : 0),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
   const_child_range children() const {
-    return const_child_range(getTrailingObjects<Stmt *>(),
+    // We always store a condition, but there is none for consteval if
+    // statements, so skip it.
+    return const_child_range(getTrailingObjects<Stmt *>() +
+                                 (isConsteval() ? thenOffset() : 0),
                              getTrailingObjects<Stmt *>() +
                                  numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == IfStmtClass;
   }
 };
 
 /// SwitchStmt - This represents a 'switch' stmt.

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_function_is_not_record : Error<
   "unexpected %0 in function call; perhaps remove the %0?">;
 def err_super_in_using_declaration : Error<
   "'__super' cannot be used with a using declaration">;
 def ext_constexpr_if : ExtWarn<
   "constexpr if is a C++17 extension">, InGroup<CXX17>;
 def warn_cxx14_compat_constexpr_if : Warning<
   "constexpr if is incompatible with C++ standards before C++17">,
   DefaultIgnore, InGroup<CXXPre17Compat>;
+def ext_consteval_if : ExtWarn<
+  "consteval if is a C++2b extension">,
+   InGroup<CXX2b>;
+def warn_cxx20_compat_consteval_if : Warning<
+  "consteval if is incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
+
 def ext_init_statement : ExtWarn<
   "'%select{if|switch}0' initialization statements are a C++17 extension">,
   InGroup<CXX17>;
 def warn_cxx14_compat_init_statement : Warning<
   "%select{if|switch}0 initialization statements are incompatible with "
   "C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>;
 def ext_for_range_init_stmt : ExtWarn<
   "range-based for loop initialization statements are a C++20 extension">,

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_static_assert_expression_is_not_constant : Error<
   "static_assert expression is not an integral constant expression">;
 def err_constexpr_if_condition_expression_is_not_constant : Error<
   "constexpr if condition is not a constant expression">;
 def err_static_assert_failed : Error<"static_assert failed%select{ %1|}0">;
 def err_static_assert_requirement_failed : Error<
   "static_assert failed due to requirement '%0'%select{ %2|}1">;
 
+def warn_consteval_if_always_true : Warning<
+  "consteval if is always true in an %select{unevaluated|immediate}0 context">,
+  InGroup<DiagGroup<"redundant-consteval-if">>;
+
 def ext_inline_variable : ExtWarn<
   "inline variables are a C++17 extension">, InGroup<CXX17>;
 def warn_cxx14_compat_inline_variable : Warning<
   "inline variables are incompatible with C++ standards before C++17">,
   DefaultIgnore, InGroup<CXXPre17Compat>;
 
 def warn_inline_namespace_reopened_noninline : Warning<
   "inline namespace reopened as a non-inline namespace">,

 def warn_unhandled_ms_attribute_ignored : Warning<
   "__declspec attribute %0 is not supported">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_has_no_effect_on_infinite_loop : Warning<
   "attribute %0 has no effect when annotating an infinite loop">,
    InGroup<IgnoredAttributes>;
 def note_attribute_has_no_effect_on_infinite_loop_here : Note<
   "annotating the infinite loop here">;
-def warn_attribute_has_no_effect_on_if_constexpr : Warning<
-  "attribute %0 has no effect when annotating an 'if constexpr' statement">,
+def warn_attribute_has_no_effect_on_compile_time_if : Warning<
+  "attribute %0 has no effect when annotating an 'if %select{constexpr|consteval}1' statement">,
    InGroup<IgnoredAttributes>;
-def note_attribute_has_no_effect_on_if_constexpr_here : Note<
-  "annotating the 'if constexpr' statement here">;
+def note_attribute_has_no_effect_on_compile_time_if_here : Note<
+  "annotating the 'if %select{constexpr|consteval}0' statement here">;
 def err_decl_attribute_invalid_on_stmt : Error<
   "%0 attribute cannot be applied to a statement">;
 def err_stmt_attribute_invalid_on_decl : Error<
   "%0 attribute cannot be applied to a declaration">;
 def warn_declspec_attribute_ignored : Warning<
   "attribute %0 is ignored, place it after "
   "\"%select{class|struct|interface|union|enum}1\" to apply attribute to "
   "type declaration">, InGroup<IgnoredAttributes>;

 def note_protected_by_variable_non_pod : Note<
   "jump bypasses initialization of non-POD variable">;
 def note_protected_by_cleanup : Note<
   "jump bypasses initialization of variable with __attribute__((cleanup))">;
 def note_protected_by_vla_typedef : Note<
   "jump bypasses initialization of VLA typedef">;
 def note_protected_by_vla_type_alias : Note<
   "jump bypasses initialization of VLA type alias">;
 def note_protected_by_constexpr_if : Note<
   "jump enters controlled statement of constexpr if">;
+def note_protected_by_consteval_if : Note<
+  "jump enters controlled statement of consteval if">;
 def note_protected_by_if_available : Note<
   "jump enters controlled statement of if available">;
 def note_protected_by_vla : Note<
   "jump bypasses initialization of variable length array">;
 def note_protected_by_objc_fast_enumeration : Note<
   "jump enters Objective-C fast enumeration loop">;
 def note_protected_by_objc_try : Note<
   "jump bypasses initialization of @try block">;

clang/include/clang/Basic/Specifiers.h

namespace clang {
   /// Define the meaning of possible values of the kind in ExplicitSpecifier.
   enum class ExplicitSpecKind : unsigned {
     ResolvedFalse,
     ResolvedTrue,
     Unresolved,
   };
 
   /// Define the kind of constexpr specifier.
   enum class ConstexprSpecKind { Unspecified, Constexpr, Consteval, Constinit };
 
+  /// In an if statement, this denotes whether the the statement is
+  /// a constexpr or consteval if statement.
+  enum class IfStatementKind : unsigned {
+    Ordinary,
+    Constexpr,
+    ConstevalNonNegated,
+    ConstevalNegated
+  };
+
   /// Specifies the width of a type, e.g., short, long, or long long.
   enum class TypeSpecifierWidth { Unspecified, Short, Long, LongLong };
 
   /// Specifies the signedness of a type, e.g., signed or unsigned.
   enum class TypeSpecifierSign { Unspecified, Signed, Unsigned };
 
   enum class TypeSpecifiersPipe { Unspecified, Pipe };
 
   /// Specifies the kind of type.
   enum TypeSpecifierType {
     TST_unspecified,

clang/include/clang/Sema/Sema.h

enum class ExpressionEvaluationContext {
     /// 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).
     ConstantEvaluated,
 
+    /// In addition of being constant evaluated, the current expression
+    /// occurs in an immediate function context - either a consteval function
+    /// or a consteval if function.
+    ImmediateFunctionContext,
+
     /// 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
     /// declarations referenced inside that expression are only used if
     /// in fact the current expression is used.
ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
           NumCleanupObjects(NumCleanupObjects), NumTypos(0),
           ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext) {}
 
     bool isUnevaluated() const {
       return Context == ExpressionEvaluationContext::Unevaluated ||
              Context == ExpressionEvaluationContext::UnevaluatedAbstract ||
              Context == ExpressionEvaluationContext::UnevaluatedList;
     }
+
     bool isConstantEvaluated() const {
-      return Context == ExpressionEvaluationContext::ConstantEvaluated;
+      return Context == ExpressionEvaluationContext::ConstantEvaluated ||
+             Context == ExpressionEvaluationContext::ImmediateFunctionContext;
+    }
+
+    bool isImmediateFunctionContext() const {
+      return Context == ExpressionEvaluationContext::ImmediateFunctionContext;
     }
   };
 
   /// A stack of expression evaluation contexts.
   SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
 
   /// Emit a warning for all pending noderef expressions that we recorded.
   void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);
StmtResult ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl,
                             SourceLocation ColonLoc, Stmt *SubStmt);
 
   StmtResult BuildAttributedStmt(SourceLocation AttrsLoc,
                                  ArrayRef<const Attr *> Attrs, Stmt *SubStmt);
   StmtResult ActOnAttributedStmt(const ParsedAttributesWithRange &AttrList,
                                  Stmt *SubStmt);
 
   class ConditionResult;
-  StmtResult ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
+
+  StmtResult ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind,
                          SourceLocation LParenLoc, Stmt *InitStmt,
                          ConditionResult Cond, SourceLocation RParenLoc,
                          Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
-  StmtResult BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
+  StmtResult BuildIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind,
                          SourceLocation LParenLoc, Stmt *InitStmt,
                          ConditionResult Cond, SourceLocation RParenLoc,
                          Stmt *ThenVal, SourceLocation ElseLoc, Stmt *ElseVal);
   StmtResult ActOnStartOfSwitchStmt(SourceLocation SwitchLoc,
                                     SourceLocation LParenLoc, Stmt *InitStmt,
                                     ConditionResult Cond,
                                     SourceLocation RParenLoc);
   StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,

   /// Determines whether we are currently in a context that
   /// is not evaluated as per C++ [expr] p5.
   bool isUnevaluatedContext() const {
     assert(!ExprEvalContexts.empty() &&
            "Must be in an expression evaluation context");
     return ExprEvalContexts.back().isUnevaluated();
   }
 
+  bool isImmediateFunctionContext() const {
+    assert(!ExprEvalContexts.empty() &&
+           "Must be in an expression evaluation context");
+    for (const ExpressionEvaluationContextRecord &context :
+         llvm::reverse(ExprEvalContexts)) {
+      if (context.isImmediateFunctionContext())
+        return true;
+      if (context.isUnevaluated())
+        return false;
+    }
+    return false;
+  }
+
   /// RAII class used to determine whether SFINAE has
   /// trapped any errors that occur during template argument
   /// deduction.
   class SFINAETrap {
     Sema &SemaRef;
     unsigned PrevSFINAEErrors;
     bool PrevInNonInstantiationSFINAEContext;
     bool PrevAccessCheckingSFINAE;

clang/lib/AST/ASTImporter.cpp

ExpectedStmt ASTNodeImporter::VisitIfStmt(IfStmt *S) {
   auto ToLParenLoc = importChecked(Err, S->getLParenLoc());
   auto ToRParenLoc = importChecked(Err, S->getRParenLoc());
   auto ToThen = importChecked(Err, S->getThen());
   auto ToElseLoc = importChecked(Err, S->getElseLoc());
   auto ToElse = importChecked(Err, S->getElse());
   if (Err)
     return std::move(Err);
 
-  return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->isConstexpr(),
+  return IfStmt::Create(Importer.getToContext(), ToIfLoc, S->getStatementKind(),
                         ToInit, ToConditionVariable, ToCond, ToLParenLoc,
                         ToRParenLoc, ToThen, ToElseLoc, ToElse);
 }
 
 ExpectedStmt ASTNodeImporter::VisitSwitchStmt(SwitchStmt *S) {
 
   Error Err = Error::success();
   auto ToInit = importChecked(Err, S->getInit());

clang/lib/AST/ExprConstant.cpp

if (const Stmt *Init = IS->getInit()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, Init);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
           return ESR_Failed;
         return ESR;
       }
     }
     bool Cond;
-    if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(), Cond))
+    if (IS->isConsteval())
+      Cond = IS->isNonNegatedConsteval();
+    else if (!EvaluateCond(Info, IS->getConditionVariable(), IS->getCond(),
+                           Cond))
       return ESR_Failed;
 
     if (const Stmt *SubStmt = Cond ? IS->getThen() : IS->getElse()) {
       EvalStmtResult ESR = EvaluateStmt(Result, Info, SubStmt);
       if (ESR != ESR_Succeeded) {
         if (ESR != ESR_Failed && !Scope.destroy())
           return ESR_Failed;
         return ESR;

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

if (!this->emitRetVoid(RS))
       return false;
     return true;
   }
 }
 
 template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitIfStmt(const IfStmt *IS) {
   BlockScope<Emitter> IfScope(this);
+
+  if (IS->isNonNegatedConsteval())
+    return visitStmt(IS->getThen());
+  if (IS->isNegatedConsteval())
+    return IS->getElse() ? visitStmt(IS->getElse()) : true;
+
   if (auto *CondInit = IS->getInit())
     if (!visitStmt(IS->getInit()))
       return false;
 
   if (const DeclStmt *CondDecl = IS->getConditionVariableDeclStmt())
     if (!visitDeclStmt(CondDecl))
       return false;
 

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *BLE) {
   JOS.attribute("value", BLE->getValue());
 }
 
 void JSONNodeDumper::VisitIfStmt(const IfStmt *IS) {
   attributeOnlyIfTrue("hasInit", IS->hasInitStorage());
   attributeOnlyIfTrue("hasVar", IS->hasVarStorage());
   attributeOnlyIfTrue("hasElse", IS->hasElseStorage());
   attributeOnlyIfTrue("isConstexpr", IS->isConstexpr());
+  attributeOnlyIfTrue("isConsteval", IS->isConsteval());
+  attributeOnlyIfTrue("constevalIsNegated", IS->isNegatedConsteval());
 }
 
 void JSONNodeDumper::VisitSwitchStmt(const SwitchStmt *SS) {
   attributeOnlyIfTrue("hasInit", SS->hasInitStorage());
   attributeOnlyIfTrue("hasVar", SS->hasVarStorage());
 }
 void JSONNodeDumper::VisitCaseStmt(const CaseStmt *CS) {
   attributeOnlyIfTrue("isGNURange", CS->caseStmtIsGNURange());

clang/lib/AST/Stmt.cpp

void MSAsmStmt::initialize(const ASTContext &C, StringRef asmstr,
   Clobbers = new (C) StringRef[NumClobbers];
   // FIXME: Avoid the allocation/copy if at all possible.
   std::transform(clobbers.begin(), clobbers.end(), Clobbers,
                  [&](StringRef Clobber) {
                    return copyIntoContext(C, Clobber);
                  });
 }
 
-IfStmt::IfStmt(const ASTContext &Ctx, SourceLocation IL, bool IsConstexpr,
+IfStmt::IfStmt(const ASTContext &Ctx, SourceLocation IL, IfStatementKind Kind,
                Stmt *Init, VarDecl *Var, Expr *Cond, SourceLocation LPL,
                SourceLocation RPL, Stmt *Then, SourceLocation EL, Stmt *Else)
     : Stmt(IfStmtClass), LParenLoc(LPL), RParenLoc(RPL) {
   bool HasElse = Else != nullptr;
   bool HasVar = Var != nullptr;
   bool HasInit = Init != nullptr;
   IfStmtBits.HasElse = HasElse;
   IfStmtBits.HasVar = HasVar;
   IfStmtBits.HasInit = HasInit;
 
-  setConstexpr(IsConstexpr);
+  setStatementKind(Kind);
 
   setCond(Cond);
   setThen(Then);
   if (HasElse)
     setElse(Else);
   if (HasVar)
     setConditionVariable(Ctx, Var);
   if (HasInit)
     setInit(Init);
 
   setIfLoc(IL);
   if (HasElse)
     setElseLoc(EL);
 }
 
 IfStmt::IfStmt(EmptyShell Empty, bool HasElse, bool HasVar, bool HasInit)
     : Stmt(IfStmtClass, Empty) {
   IfStmtBits.HasElse = HasElse;
   IfStmtBits.HasVar = HasVar;
   IfStmtBits.HasInit = HasInit;
 }
 
 IfStmt *IfStmt::Create(const ASTContext &Ctx, SourceLocation IL,
-                       bool IsConstexpr, Stmt *Init, VarDecl *Var, Expr *Cond,
-                       SourceLocation LPL, SourceLocation RPL, Stmt *Then,
-                       SourceLocation EL, Stmt *Else) {
+                       IfStatementKind Kind, Stmt *Init, VarDecl *Var,
+                       Expr *Cond, SourceLocation LPL, SourceLocation RPL,
+                       Stmt *Then, SourceLocation EL, Stmt *Else) {
   bool HasElse = Else != nullptr;
   bool HasVar = Var != nullptr;
   bool HasInit = Init != nullptr;
   void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *, SourceLocation>(
           NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),
       alignof(IfStmt));
   return new (Mem)
-      IfStmt(Ctx, IL, IsConstexpr, Init, Var, Cond, LPL, RPL, Then, EL, Else);
+      IfStmt(Ctx, IL, Kind, Init, Var, Cond, LPL, RPL, Then, EL, Else);
 }
 
 IfStmt *IfStmt::CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar,
                             bool HasInit) {
   void *Mem = Ctx.Allocate(
       totalSizeToAlloc<Stmt *, SourceLocation>(
           NumMandatoryStmtPtr + HasElse + HasVar + HasInit, HasElse),
       alignof(IfStmt));

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
   for (const auto *Attr : Node->getAttrs()) {
     Attr->printPretty(OS, Policy);
   }
 
   PrintStmt(Node->getSubStmt(), 0);
 }
 
 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
+  if (If->isConsteval()) {
+    OS << "if ";
+    if (If->isNegatedConsteval())
+      OS << "!";
+    OS << "consteval";
+    OS << NL;
+    PrintStmt(If->getThen());
+    if (Stmt *Else = If->getElse()) {
+      Indent();
+      OS << "else";
+      PrintStmt(Else);
+      OS << NL;
+    }
+    return;
+  }
+
   OS << "if (";
   if (If->getInit())
     PrintInitStmt(If->getInit(), 4);
   if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
     PrintRawDeclStmt(DS);
   else
     PrintExpr(If->getCond());
   OS << ')';

clang/lib/AST/TextNodeDumper.cpp

 
 void TextNodeDumper::VisitIfStmt(const IfStmt *Node) {
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
     OS << " has_var";
   if (Node->hasElseStorage())
     OS << " has_else";
+  if (Node->isConstexpr())
+    OS << " constexpr";
+  if (Node->isConsteval()) {
+    OS << " ";
+    if (Node->isNegatedConsteval())
+      OS << "!";
+    OS << "consteval";
+  }
 }
 
 void TextNodeDumper::VisitSwitchStmt(const SwitchStmt *Node) {
   if (Node->hasInitStorage())
     OS << " has_init";
   if (Node->hasVarStorage())
     OS << " has_var";
 }

clang/lib/Analysis/BodyFarm.cpp

UnaryOperator *FlagCheck = UnaryOperator::Create(
       /* CanOverflow*/ false, FPOptionsOverride());
 
   // Create assignment.
   BinaryOperator *FlagAssignment = M.makeAssignment(
       Deref, M.makeIntegralCast(M.makeIntegerLiteral(1, C.IntTy), DerefType),
       DerefType);
 
   auto *Out =
-      IfStmt::Create(C, SourceLocation(),
-                     /* IsConstexpr=*/false,
+      IfStmt::Create(C, SourceLocation(), IfStatementKind::Ordinary,
                      /* Init=*/nullptr,
                      /* Var=*/nullptr,
                      /* Cond=*/FlagCheck,
                      /* LPL=*/SourceLocation(),
                      /* RPL=*/SourceLocation(),
                      /* Then=*/M.makeCompound({CallbackCall, FlagAssignment}));
 
   return Out;
M.makeLvalueToRvalue(
         M.makeLvalueToRvalue(
           M.makeDeclRefExpr(Predicate),
           PredicateQPtrTy),
         PredicateTy),
     PredicateTy);
 
   Expr *GuardCondition = M.makeComparison(LValToRval, DoneValue, BO_NE);
   // (5) Create the 'if' statement.
-  auto *If = IfStmt::Create(C, SourceLocation(),
-                            /* IsConstexpr=*/false,
+  auto *If = IfStmt::Create(C, SourceLocation(), IfStatementKind::Ordinary,
                             /* Init=*/nullptr,
                             /* Var=*/nullptr,
                             /* Cond=*/GuardCondition,
                             /* LPL=*/SourceLocation(),
                             /* RPL=*/SourceLocation(),
                             /* Then=*/CS);
   return If;
 }
static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D)
   // Construct the else clause.
   BoolVal = M.makeObjCBool(false);
   RetVal = isBoolean ? M.makeIntegralCastToBoolean(BoolVal)
                      : M.makeIntegralCast(BoolVal, ResultTy);
   Stmt *Else = M.makeReturn(RetVal);
 
   /// Construct the If.
   auto *If =
-      IfStmt::Create(C, SourceLocation(),
-                     /* IsConstexpr=*/false,
+      IfStmt::Create(C, SourceLocation(), IfStatementKind::Ordinary,
                      /* Init=*/nullptr,
                      /* Var=*/nullptr, Comparison,
                      /* LPL=*/SourceLocation(),
                      /* RPL=*/SourceLocation(), Body, SourceLocation(), Else);
 
   return If;
 }
 

clang/lib/Analysis/CFG.cpp

CFGBlock *CFGBuilder::VisitIfStmt(IfStmt *I) {
   // Specially handle "if (expr1 || ...)" and "if (expr1 && ...)" by
   // having these handle the actual control-flow jump.  Note that
   // if we introduce a condition variable, e.g. "if (int x = exp1 || exp2)"
   // we resort to the old control-flow behavior.  This special handling
   // removes infeasible paths from the control-flow graph by having the
   // control-flow transfer of '&&' or '||' go directly into the then/else
   // blocks directly.
   BinaryOperator *Cond =
-      I->getConditionVariable()
+      (I->isConsteval() || I->getConditionVariable())
           ? nullptr
           : dyn_cast<BinaryOperator>(I->getCond()->IgnoreParens());
   CFGBlock *LastBlock;
   if (Cond && Cond->isLogicalOp())
     LastBlock = VisitLogicalOperator(Cond, I, ThenBlock, ElseBlock).first;
   else {
     // Now create a new block containing the if statement.
     Block = createBlock(false);
 
     // Set the terminator of the new block to the If statement.
     Block->setTerminator(I);
 
     // See if this is a known constant.
-    const TryResult &KnownVal = tryEvaluateBool(I->getCond());
+    TryResult KnownVal;
+    if (!I->isConsteval())
+      KnownVal = tryEvaluateBool(I->getCond());
 
     // Add the successors.  If we know that specific branches are
     // unreachable, inform addSuccessor() of that knowledge.
     addSuccessor(Block, ThenBlock, /* IsReachable = */ !KnownVal.isFalse());
     addSuccessor(Block, ElseBlock, /* IsReachable = */ !KnownVal.isTrue());
 
     // Add the condition as the last statement in the new block.  This may
     // create new blocks as the condition may contain control-flow.  Any newly

clang/lib/CodeGen/CGStmt.cpp

void CodeGenFunction::EmitIndirectGotoStmt(const IndirectGotoStmt &S) {
   // The first instruction in the block has to be the PHI for the switch dest,
   // add an entry for this branch.
   cast<llvm::PHINode>(IndGotoBB->begin())->addIncoming(V, CurBB);
 
   EmitBranch(IndGotoBB);
 }
 
 void CodeGenFunction::EmitIfStmt(const IfStmt &S) {
+  // The else branch of a consteval if statement is always the only branch that
+  // can be runtime evaluated.
+  if (S.isConsteval()) {
+    const Stmt *Executed = S.isNegatedConsteval() ? S.getThen() : S.getElse();
+    if (Executed) {
+      RunCleanupsScope ExecutedScope(*this);
+      EmitStmt(Executed);
+    }
+    return;
+  }
+
   // C99 6.8.4.1: The first substatement is executed if the expression compares
   // unequal to 0.  The condition must be a scalar type.
   LexicalScope ConditionScope(*this, S.getCond()->getSourceRange());
 
   if (S.getInit())
     EmitStmt(S.getInit());
 
   if (S.getConditionVariable())

clang/lib/CodeGen/CodeGenPGO.cpp

void VisitSwitchCase(const SwitchCase *S) {
     // for branch probabilities.
     CountMap[S] = CaseCount;
     RecordNextStmtCount = true;
     Visit(S->getSubStmt());
   }
 
   void VisitIfStmt(const IfStmt *S) {
     RecordStmtCount(S);
+
+    if (S->isConsteval()) {
+      const Stmt *Stm = S->isNegatedConsteval() ? S->getThen() : S->getElse();
+      if (Stm)
+        Visit(Stm);
+      return;
+    }
+
     uint64_t ParentCount = CurrentCount;
     if (S->getInit())
       Visit(S->getInit());
     Visit(S->getCond());
 
     // Counter tracks the "then" part of an if statement. The count for
     // the "else" part, if it exists, will be calculated from this counter.
     uint64_t ThenCount = setCount(PGO.getRegionCount(S));

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus20) {
     Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
     //Builder.defineMacro("__cpp_modules", "201907L");
     Builder.defineMacro("__cpp_using_enum", "201907L");
   }
   // C++2b features.
   if (LangOpts.CPlusPlus2b) {
     Builder.defineMacro("__cpp_implicit_move", "202011L");
     Builder.defineMacro("__cpp_size_t_suffix", "202011L");
+    Builder.defineMacro("__cpp_if_consteval", "202106L");
   }
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201811L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 
   // TS features.
   if (LangOpts.Coroutines)
     Builder.defineMacro("__cpp_coroutines", "201703L");

clang/lib/Parse/ParseStmt.cpp

 }
 
 /// ParseIfStatement
 ///       if-statement: [C99 6.8.4.1]
 ///         'if' '(' expression ')' statement
 ///         'if' '(' expression ')' statement 'else' statement
 /// [C++]   'if' '(' condition ')' statement
 /// [C++]   'if' '(' condition ')' statement 'else' statement
+/// [C++23] 'if' '!' [opt] consteval compound-statement
+/// [C++23] 'if' '!' [opt] consteval compound-statement 'else' statement
 ///
 StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   assert(Tok.is(tok::kw_if) && "Not an if stmt!");
   SourceLocation IfLoc = ConsumeToken();  // eat the 'if'.
 
   bool IsConstexpr = false;
+  bool IsConsteval = false;
+  SourceLocation NotLocation;
+  SourceLocation ConstevalLoc;
+
   if (Tok.is(tok::kw_constexpr)) {
     Diag(Tok, getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_constexpr_if
                                         : diag::ext_constexpr_if);
     IsConstexpr = true;
     ConsumeToken();
+  } else {
+    if (Tok.is(tok::exclaim)) {
+      NotLocation = ConsumeToken();
     }
 
-  if (Tok.isNot(tok::l_paren)) {
+    if (Tok.is(tok::kw_consteval)) {
+      Diag(Tok, getLangOpts().CPlusPlus2b ? diag::warn_cxx20_compat_consteval_if
+                                          : diag::ext_consteval_if);
+      IsConsteval = true;
+      ConstevalLoc = ConsumeToken();
+    }
+  }
+  if (!IsConsteval && (NotLocation.isValid() || Tok.isNot(tok::l_paren))) {
     Diag(Tok, diag::err_expected_lparen_after) << "if";
     SkipUntil(tok::semi);
     return StmtError();
   }
 
   bool C99orCXX = getLangOpts().C99 || getLangOpts().CPlusPlus;
 
   // C99 6.8.4p3 - In C99, the if statement is a block.  This is not
   // the case for C90.
   //
   // C++ 6.4p3:
   // A name introduced by a declaration in a condition is in scope from its
   // point of declaration until the end of the substatements controlled by the
   // condition.
   // C++ 3.3.2p4:
   // Names declared in the for-init-statement, and in the condition of if,
   // while, for, and switch statements are local to the if, while, for, or
   // switch statement (including the controlled statement).
   //
   ParseScope IfScope(this, Scope::DeclScope | Scope::ControlScope, C99orCXX);
 
   // Parse the condition.
   StmtResult InitStmt;
   Sema::ConditionResult Cond;
   SourceLocation LParen;
   SourceLocation RParen;
+  llvm::Optional<bool> ConstexprCondition;
+  if (!IsConsteval) {
+
     if (ParseParenExprOrCondition(&InitStmt, Cond, IfLoc,
                                   IsConstexpr ? Sema::ConditionKind::ConstexprIf
                                               : Sema::ConditionKind::Boolean,
                                   &LParen, &RParen))
       return StmtError();
 
-  llvm::Optional<bool> ConstexprCondition;
     if (IsConstexpr)
       ConstexprCondition = Cond.getKnownValue();
+  }
 
   bool IsBracedThen = Tok.is(tok::l_brace);
 
   // C99 6.8.4p3 - In C99, the body of the if statement is a scope, even if
   // there is no compound stmt.  C90 does not have this clause.  We only do this
   // if the body isn't a compound statement to avoid push/pop in common cases.
   //
   // C++ 6.4p1:
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   MisleadingIndentationChecker MIChecker(*this, MSK_if, IfLoc);
 
   // Read the 'then' stmt.
   SourceLocation ThenStmtLoc = Tok.getLocation();
 
   SourceLocation InnerStatementTrailingElseLoc;
   StmtResult ThenStmt;
   {
+    bool ShouldEnter =
+        (ConstexprCondition && !*ConstexprCondition) || IsConsteval;
+    Sema::ExpressionEvaluationContext Context =
+        Sema::ExpressionEvaluationContext::DiscardedStatement;
+    if (NotLocation.isInvalid() && IsConsteval)
+      Context = Sema::ExpressionEvaluationContext::ImmediateFunctionContext;
+
     EnterExpressionEvaluationContext PotentiallyDiscarded(
-        Actions, Sema::ExpressionEvaluationContext::DiscardedStatement, nullptr,
-        Sema::ExpressionEvaluationContextRecord::EK_Other,
-        /*ShouldEnter=*/ConstexprCondition && !*ConstexprCondition);
+        Actions, Context, nullptr,
+        Sema::ExpressionEvaluationContextRecord::EK_Other, ShouldEnter);
     ThenStmt = ParseStatement(&InnerStatementTrailingElseLoc);
   }
 
   if (Tok.isNot(tok::kw_else))
     MIChecker.Check();
 
   // Pop the 'if' scope if needed.
   InnerScope.Exit();
 
if (Tok.is(tok::kw_else)) {
     // C++ 6.4p1:
     // The substatement in a selection-statement (each substatement, in the else
     // form of the if statement) implicitly defines a local scope.
     //
     ParseScope InnerScope(this, Scope::DeclScope, C99orCXX,
                           Tok.is(tok::l_brace));
 
     MisleadingIndentationChecker MIChecker(*this, MSK_else, ElseLoc);
+    bool ShouldEnter =
+        (ConstexprCondition && *ConstexprCondition) || IsConsteval;
+    Sema::ExpressionEvaluationContext Context =
+        Sema::ExpressionEvaluationContext::DiscardedStatement;
+    if (NotLocation.isValid() && IsConsteval)
+      Context = Sema::ExpressionEvaluationContext::ImmediateFunctionContext;
 
     EnterExpressionEvaluationContext PotentiallyDiscarded(
-        Actions, Sema::ExpressionEvaluationContext::DiscardedStatement, nullptr,
-        Sema::ExpressionEvaluationContextRecord::EK_Other,
-        /*ShouldEnter=*/ConstexprCondition && *ConstexprCondition);
+        Actions, Context, nullptr,
+        Sema::ExpressionEvaluationContextRecord::EK_Other, ShouldEnter);
     ElseStmt = ParseStatement();
 
     if (ElseStmt.isUsable())
       MIChecker.Check();
 
     // Pop the 'else' scope if needed.
     InnerScope.Exit();
   } else if (Tok.is(tok::code_completion)) {
StmtResult Parser::ParseIfStatement(SourceLocation *TrailingElseLoc) {
   // part.  If both are invalid, return error.
   if ((ThenStmt.isInvalid() && ElseStmt.isInvalid()) ||
       (ThenStmt.isInvalid() && ElseStmt.get() == nullptr) ||
       (ThenStmt.get() == nullptr && ElseStmt.isInvalid())) {
     // Both invalid, or one is invalid and other is non-present: return error.
     return StmtError();
   }
 
+  if (IsConsteval) {
+    auto IsCompoundStatement = [](const Stmt *S) {
+      if (const auto *Outer = dyn_cast_or_null<AttributedStmt>(S))
+        S = Outer->getSubStmt();
+      return isa_and_nonnull<clang::CompoundStmt>(S);
+    };
+
+    if (!IsCompoundStatement(ThenStmt.get())) {
+      Diag(ConstevalLoc, diag::err_expected_after) << "consteval"
+                                                   << "{";
+      return StmtError();
+    }
+    if (!ElseStmt.isUnset() && !IsCompoundStatement(ElseStmt.get())) {
+      Diag(ElseLoc, diag::err_expected_after) << "else"
+                                              << "{";
+      return StmtError();
+    }
+  }
+
   // Now if either are invalid, replace with a ';'.
   if (ThenStmt.isInvalid())
     ThenStmt = Actions.ActOnNullStmt(ThenStmtLoc);
   if (ElseStmt.isInvalid())
     ElseStmt = Actions.ActOnNullStmt(ElseStmtLoc);
 
-  return Actions.ActOnIfStmt(IfLoc, IsConstexpr, LParen, InitStmt.get(), Cond,
-                             RParen, ThenStmt.get(), ElseLoc, ElseStmt.get());
+  IfStatementKind Kind = IfStatementKind::Ordinary;
+  if (IsConstexpr)
+    Kind = IfStatementKind::Constexpr;
+  else if (IsConsteval)
+    Kind = NotLocation.isValid() ? IfStatementKind::ConstevalNegated
+                                 : IfStatementKind::ConstevalNonNegated;
+
+  return Actions.ActOnIfStmt(IfLoc, Kind, LParen, InitStmt.get(), Cond, RParen,
+                             ThenStmt.get(), ElseLoc, ElseStmt.get());
 }
 
 /// ParseSwitchStatement
 ///       switch-statement:
 ///         'switch' '(' expression ')' statement
 /// [C++]   'switch' '(' condition ')' statement
 StmtResult Parser::ParseSwitchStatement(SourceLocation *TrailingElseLoc) {
   assert(Tok.is(tok::kw_switch) && "Not a switch stmt!");

clang/lib/Sema/JumpDiagnostics.cpp

if (auto *GS = dyn_cast<GCCAsmStmt>(S))
         AsmJumps.push_back(GS);
         for (auto *E : GS->labels())
           AsmJumpTargets.push_back(E->getLabel());
       }
     break;
 
   case Stmt::IfStmtClass: {
     IfStmt *IS = cast<IfStmt>(S);
-    if (!(IS->isConstexpr() || IS->isObjCAvailabilityCheck()))
+    if (!(IS->isConstexpr() || IS->isConsteval() ||
+          IS->isObjCAvailabilityCheck()))
       break;
 
-    unsigned Diag = IS->isConstexpr() ? diag::note_protected_by_constexpr_if
-                                      : diag::note_protected_by_if_available;
+    unsigned Diag = diag::note_protected_by_if_available;
+    if (IS->isConstexpr())
+      Diag = diag::note_protected_by_constexpr_if;
+    else if (IS->isConsteval())
+      Diag = diag::note_protected_by_consteval_if;
 
     if (VarDecl *Var = IS->getConditionVariable())
       BuildScopeInformation(Var, ParentScope);
 
     // Cannot jump into the middle of the condition.
     unsigned NewParentScope = Scopes.size();
     Scopes.push_back(GotoScope(ParentScope, Diag, 0, IS->getBeginLoc()));
+
+    if (!IS->isConsteval())
       BuildScopeInformation(IS->getCond(), NewParentScope);
 
     // Jumps into either arm of an 'if constexpr' are not allowed.
     NewParentScope = Scopes.size();
     Scopes.push_back(GotoScope(ParentScope, Diag, 0, IS->getBeginLoc()));
     BuildScopeInformation(IS->getThen(), NewParentScope);
     if (Stmt *Else = IS->getElse()) {
       NewParentScope = Scopes.size();
       Scopes.push_back(GotoScope(ParentScope, Diag, 0, IS->getBeginLoc()));

clang/lib/Sema/SemaDeclCXX.cpp

if (NotCond.isInvalid())
       return StmtError();
 
     ExprResult False = S.ActOnCXXBoolLiteral(Loc, tok::kw_false);
     assert(!False.isInvalid() && "should never fail");
     StmtResult ReturnFalse = S.BuildReturnStmt(Loc, False.get());
     if (ReturnFalse.isInvalid())
       return StmtError();
 
-    return S.ActOnIfStmt(Loc, false, Loc, nullptr,
+    return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, nullptr,
                          S.ActOnCondition(nullptr, Loc, NotCond.get(),
                                           Sema::ConditionKind::Boolean),
                          Loc, ReturnFalse.get(), SourceLocation(), nullptr);
   }
 
   StmtResult visitSubobjectArray(QualType Type, llvm::APInt Size,
                                  ExprPair Subobj) {
     QualType SizeType = S.Context.getSizeType();
case DefaultedComparisonKind::ThreeWay: {
       VDRef = getDecl(VD);
       if (VDRef.isInvalid())
         return StmtError();
       StmtResult ReturnStmt = S.BuildReturnStmt(Loc, VDRef.get());
       if (ReturnStmt.isInvalid())
         return StmtError();
 
       // if (...)
-      return S.ActOnIfStmt(Loc, /*IsConstexpr=*/false, Loc, InitStmt, Cond, Loc,
-                           ReturnStmt.get(),
+      return S.ActOnIfStmt(Loc, IfStatementKind::Ordinary, Loc, InitStmt, Cond,
+                           Loc, ReturnStmt.get(),
                            /*ElseLoc=*/SourceLocation(), /*Else=*/nullptr);
     }
 
     case DefaultedComparisonKind::NotEqual:
     case DefaultedComparisonKind::Relational:
       // C++2a [class.compare.secondary]p2:
       //   Otherwise, the operator function yields x @ y.
       return Op.get();

clang/lib/Sema/SemaExpr.cpp

 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/OperationKinds.h"
+#include "clang/AST/ParentMapContext.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LiteralSupport.h"
if (BO->getOpcode() == BO_Assign) {
                  LHSs.end());
     }
   }
 }
 
 ExprResult Sema::CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl) {
   if (isUnevaluatedContext() || !E.isUsable() || !Decl ||
       !Decl->isConsteval() || isConstantEvaluated() ||
-      RebuildingImmediateInvocation)
+      RebuildingImmediateInvocation || isImmediateFunctionContext())
     return E;
 
   /// Opportunistically remove the callee from ReferencesToConsteval if we can.
   /// It's OK if this fails; we'll also remove this in
   /// HandleImmediateInvocations, but catching it here allows us to avoid
   /// walking the AST looking for it in simple cases.
   if (auto *Call = dyn_cast<CallExpr>(E.get()->IgnoreImplicit()))
     if (auto *DeclRef =

 
 /// Are we in a context that is potentially constant evaluated per C++20
 /// [expr.const]p12?
 static bool isPotentiallyConstantEvaluatedContext(Sema &SemaRef) {
   /// C++2a [expr.const]p12:
   //   An expression or conversion is potentially constant evaluated if it is
   switch (SemaRef.ExprEvalContexts.back().Context) {
     case Sema::ExpressionEvaluationContext::ConstantEvaluated:
+    case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
+
       // -- a manifestly constant-evaluated expression,
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
     case Sema::ExpressionEvaluationContext::DiscardedStatement:
       // -- a potentially-evaluated expression,
     case Sema::ExpressionEvaluationContext::UnevaluatedList:
       // -- an immediate subexpression of a braced-init-list,
 
static OdrUseContext isOdrUseContext(Sema &SemaRef) {
 
   switch (SemaRef.ExprEvalContexts.back().Context) {
     case Sema::ExpressionEvaluationContext::Unevaluated:
     case Sema::ExpressionEvaluationContext::UnevaluatedList:
     case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
       return OdrUseContext::None;
 
     case Sema::ExpressionEvaluationContext::ConstantEvaluated:
+    case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
     case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
       Result = OdrUseContext::Used;
       break;
 
     case Sema::ExpressionEvaluationContext::DiscardedStatement:
       Result = OdrUseContext::FormallyOdrUsed;
       break;
 
bool Sema::DiagRuntimeBehavior(SourceLocation Loc, ArrayRef<const Stmt*> Stmts,
   case ExpressionEvaluationContext::Unevaluated:
   case ExpressionEvaluationContext::UnevaluatedList:
   case ExpressionEvaluationContext::UnevaluatedAbstract:
   case ExpressionEvaluationContext::DiscardedStatement:
     // The argument will never be evaluated, so don't complain.
     break;
 
   case ExpressionEvaluationContext::ConstantEvaluated:
+  case ExpressionEvaluationContext::ImmediateFunctionContext:
     // Relevant diagnostics should be produced by constant evaluation.
     break;
 
   case ExpressionEvaluationContext::PotentiallyEvaluated:
   case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
     return DiagIfReachable(Loc, Stmts, PD);
   }
 

clang/lib/Sema/SemaExprMember.cpp

case Sema::ExpressionEvaluationContext::UnevaluatedList:
     break;
 
   case Sema::ExpressionEvaluationContext::UnevaluatedAbstract:
     AbstractInstanceResult = IMA_Abstract;
     break;
 
   case Sema::ExpressionEvaluationContext::DiscardedStatement:
   case Sema::ExpressionEvaluationContext::ConstantEvaluated:
+  case Sema::ExpressionEvaluationContext::ImmediateFunctionContext:
   case Sema::ExpressionEvaluationContext::PotentiallyEvaluated:
   case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
     break;
   }
 
   // If the current context is not an instance method, it can't be
   // an implicit member reference.
   if (isStaticContext) {

clang/lib/Sema/SemaLambda.cpp

void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
 
   // Add lambda parameters into scope.
   addLambdaParameters(Intro.Captures, Method, CurScope);
 
   // Enter a new evaluation context to insulate the lambda from any
   // cleanups from the enclosing full-expression.
   PushExpressionEvaluationContext(
       LSI->CallOperator->isConsteval()
-          ? ExpressionEvaluationContext::ConstantEvaluated
+          ? ExpressionEvaluationContext::ImmediateFunctionContext
           : ExpressionEvaluationContext::PotentiallyEvaluated);
 }
 
 void Sema::ActOnLambdaError(SourceLocation StartLoc, Scope *CurScope,
                             bool IsInstantiation) {
   LambdaScopeInfo *LSI = cast<LambdaScopeInfo>(FunctionScopes.back());
 
   // Leave the expression-evaluation context.
if (!CurContext->isDependentContext()) {
     //   evaluation of e, following the rules of the abstract machine, would
     //   evaluate [...] a lambda-expression.
     //
     // This is technically incorrect, there are some constant evaluated contexts
     // where this should be allowed.  We should probably fix this when DR1607 is
     // ratified, it lays out the exact set of conditions where we shouldn't
     // allow a lambda-expression.
     case ExpressionEvaluationContext::ConstantEvaluated:
+    case ExpressionEvaluationContext::ImmediateFunctionContext:
       // We don't actually diagnose this case immediately, because we
       // could be within a context where we might find out later that
       // the expression is potentially evaluated (e.g., for typeid).
       ExprEvalContexts.back().Lambdas.push_back(Lambda);
       break;
 
     case ExpressionEvaluationContext::DiscardedStatement:
     case ExpressionEvaluationContext::PotentiallyEvaluated:

clang/lib/Sema/SemaStmt.cpp

public:
   void VisitBinaryOperator(BinaryOperator *E) {
     if (E->getOpcode() == BO_Comma)
       SemaRef.DiagnoseCommaOperator(E->getLHS(), E->getExprLoc());
     EvaluatedExprVisitor<CommaVisitor>::VisitBinaryOperator(E);
   }
 };
 }
 
-StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
+StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc,
+                             IfStatementKind StatementKind,
                              SourceLocation LParenLoc, Stmt *InitStmt,
                              ConditionResult Cond, SourceLocation RParenLoc,
                              Stmt *thenStmt, SourceLocation ElseLoc,
                              Stmt *elseStmt) {
   if (Cond.isInvalid())
     Cond = ConditionResult(
         *this, nullptr,
         MakeFullExpr(new (Context) OpaqueValueExpr(SourceLocation(),
                                                    Context.BoolTy, VK_PRValue),
                      IfLoc),
         false);
 
+  bool ConstevalOrNegatedConsteval =
+      StatementKind == IfStatementKind::ConstevalNonNegated ||
+      StatementKind == IfStatementKind::ConstevalNegated;
+
   Expr *CondExpr = Cond.get().second;
+  assert((CondExpr || ConstevalOrNegatedConsteval) &&
+         "If statement: missing condition");
   // Only call the CommaVisitor when not C89 due to differences in scope flags.
-  if ((getLangOpts().C99 || getLangOpts().CPlusPlus) &&
+  if (CondExpr && (getLangOpts().C99 || getLangOpts().CPlusPlus) &&
       !Diags.isIgnored(diag::warn_comma_operator, CondExpr->getExprLoc()))
     CommaVisitor(*this).Visit(CondExpr);
 
-  if (!elseStmt)
+  if (!ConstevalOrNegatedConsteval && !elseStmt)
     DiagnoseEmptyStmtBody(CondExpr->getEndLoc(), thenStmt,
                           diag::warn_empty_if_body);
 
-  if (IsConstexpr) {
+  if (ConstevalOrNegatedConsteval ||
+      StatementKind == IfStatementKind::Constexpr) {
     auto DiagnoseLikelihood = [&](const Stmt *S) {
       if (const Attr *A = Stmt::getLikelihoodAttr(S)) {
         Diags.Report(A->getLocation(),
-                     diag::warn_attribute_has_no_effect_on_if_constexpr)
-            << A << A->getRange();
+                     diag::warn_attribute_has_no_effect_on_compile_time_if)
+            << A << ConstevalOrNegatedConsteval << A->getRange();
         Diags.Report(IfLoc,
-                     diag::note_attribute_has_no_effect_on_if_constexpr_here)
-            << SourceRange(IfLoc, LParenLoc.getLocWithOffset(-1));
+                     diag::note_attribute_has_no_effect_on_compile_time_if_here)
+            << ConstevalOrNegatedConsteval
+            << SourceRange(IfLoc, (ConstevalOrNegatedConsteval
+                                       ? thenStmt->getBeginLoc()
+                                       : LParenLoc)
+                                      .getLocWithOffset(-1));
       }
     };
     DiagnoseLikelihood(thenStmt);
     DiagnoseLikelihood(elseStmt);
   } else {
     std::tuple<bool, const Attr *, const Attr *> LHC =
         Stmt::determineLikelihoodConflict(thenStmt, elseStmt);
     if (std::get<0>(LHC)) {
       const Attr *ThenAttr = std::get<1>(LHC);
       const Attr *ElseAttr = std::get<2>(LHC);
       Diags.Report(ThenAttr->getLocation(),
                    diag::warn_attributes_likelihood_ifstmt_conflict)
           << ThenAttr << ThenAttr->getRange();
       Diags.Report(ElseAttr->getLocation(), diag::note_conflicting_attribute)
           << ElseAttr << ElseAttr->getRange();
     }
   }
 
-  return BuildIfStmt(IfLoc, IsConstexpr, LParenLoc, InitStmt, Cond, RParenLoc,
+  if (ConstevalOrNegatedConsteval) {
+    bool Immediate = isImmediateFunctionContext();
+    if (CurContext->isFunctionOrMethod()) {
+      const auto *FD =
+          dyn_cast<FunctionDecl>(Decl::castFromDeclContext(CurContext));
+      if (FD && FD->isConsteval())
+        Immediate = true;
+    }
+    if (isUnevaluatedContext() || Immediate)
+      Diags.Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;
+  }
+
+  return BuildIfStmt(IfLoc, StatementKind, LParenLoc, InitStmt, Cond, RParenLoc,
                      thenStmt, ElseLoc, elseStmt);
 }
 
-StmtResult Sema::BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
+StmtResult Sema::BuildIfStmt(SourceLocation IfLoc,
+                             IfStatementKind StatementKind,
                              SourceLocation LParenLoc, Stmt *InitStmt,
                              ConditionResult Cond, SourceLocation RParenLoc,
                              Stmt *thenStmt, SourceLocation ElseLoc,
                              Stmt *elseStmt) {
   if (Cond.isInvalid())
     return StmtError();
 
-  if (IsConstexpr || isa<ObjCAvailabilityCheckExpr>(Cond.get().second))
+  if (StatementKind != IfStatementKind::Ordinary ||
+      isa<ObjCAvailabilityCheckExpr>(Cond.get().second))
     setFunctionHasBranchProtectedScope();
 
-  return IfStmt::Create(Context, IfLoc, IsConstexpr, InitStmt, Cond.get().first,
-                        Cond.get().second, LParenLoc, RParenLoc, thenStmt,
-                        ElseLoc, elseStmt);
+  return IfStmt::Create(Context, IfLoc, StatementKind, InitStmt,
+                        Cond.get().first, Cond.get().second, LParenLoc,
+                        RParenLoc, thenStmt, ElseLoc, elseStmt);
 }
 
 namespace {
   struct CaseCompareFunctor {
     bool operator()(const std::pair<llvm::APSInt, CaseStmt*> &LHS,
                     const llvm::APSInt &RHS) {
       return LHS.first < RHS;
     }

clang/lib/Sema/TreeTransform.h

StmtResult RebuildAttributedStmt(SourceLocation AttrLoc,
                                    Stmt *SubStmt) {
     return SemaRef.BuildAttributedStmt(AttrLoc, Attrs, SubStmt);
   }
 
   /// Build a new "if" statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
-  StmtResult RebuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
+  StmtResult RebuildIfStmt(SourceLocation IfLoc, IfStatementKind Kind,
                            SourceLocation LParenLoc, Sema::ConditionResult Cond,
                            SourceLocation RParenLoc, Stmt *Init, Stmt *Then,
                            SourceLocation ElseLoc, Stmt *Else) {
-    return getSema().ActOnIfStmt(IfLoc, IsConstexpr, LParenLoc, Init, Cond,
-                                 RParenLoc, Then, ElseLoc, Else);
+    return getSema().ActOnIfStmt(IfLoc, Kind, LParenLoc, Init, Cond, RParenLoc,
+                                 Then, ElseLoc, Else);
   }
 
   /// Start building a new switch statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   StmtResult RebuildSwitchStmtStart(SourceLocation SwitchLoc,
                                     SourceLocation LParenLoc, Stmt *Init,

 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
   // Transform the initialization statement
   StmtResult Init = getDerived().TransformStmt(S->getInit());
   if (Init.isInvalid())
     return StmtError();
 
+  Sema::ConditionResult Cond;
+  if (!S->isConsteval()) {
     // Transform the condition
-  Sema::ConditionResult Cond = getDerived().TransformCondition(
+    Cond = getDerived().TransformCondition(
         S->getIfLoc(), S->getConditionVariable(), S->getCond(),
         S->isConstexpr() ? Sema::ConditionKind::ConstexprIf
                          : Sema::ConditionKind::Boolean);
     if (Cond.isInvalid())
       return StmtError();
+  }
 
   // If this is a constexpr if, determine which arm we should instantiate.
   llvm::Optional<bool> ConstexprConditionValue;
   if (S->isConstexpr())
     ConstexprConditionValue = Cond.getKnownValue();
 
   // Transform the "then" branch.
   StmtResult Then;
TreeTransform<Derived>::TransformIfStmt(IfStmt *S) {
   if (!getDerived().AlwaysRebuild() &&
       Init.get() == S->getInit() &&
       Cond.get() == std::make_pair(S->getConditionVariable(), S->getCond()) &&
       Then.get() == S->getThen() &&
       Else.get() == S->getElse())
     return S;
 
   return getDerived().RebuildIfStmt(
-      S->getIfLoc(), S->isConstexpr(), S->getLParenLoc(), Cond,
+      S->getIfLoc(), S->getStatementKind(), S->getLParenLoc(), Cond,
       S->getRParenLoc(), Init.get(), Then.get(), S->getElseLoc(), Else.get());
 }
 
 template<typename Derived>
 StmtResult
 TreeTransform<Derived>::TransformSwitchStmt(SwitchStmt *S) {
   // Transform the initialization statement
   StmtResult Init = getDerived().TransformStmt(S->getInit());

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
   std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
   S->SubStmt = Record.readSubStmt();
   S->AttributedStmtBits.AttrLoc = readSourceLocation();
 }
 
 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
 
-  S->setConstexpr(Record.readInt());
   bool HasElse = Record.readInt();
   bool HasVar = Record.readInt();
   bool HasInit = Record.readInt();
 
+  S->setStatementKind(static_cast<IfStatementKind>(Record.readInt()));
   S->setCond(Record.readSubExpr());
   S->setThen(Record.readSubStmt());
   if (HasElse)
     S->setElse(Record.readSubStmt());
   if (HasVar)
     S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
   if (HasInit)
     S->setInit(Record.readSubStmt());
case STMT_ATTRIBUTED:
       S = AttributedStmt::CreateEmpty(
         Context,
         /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
       break;
 
     case STMT_IF:
       S = IfStmt::CreateEmpty(
           Context,
-          /* HasElse=*/Record[ASTStmtReader::NumStmtFields + 1],
-          /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 2],
-          /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 3]);
+          /* HasElse=*/Record[ASTStmtReader::NumStmtFields],
+          /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1],
+          /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 2]);
       break;
 
     case STMT_SWITCH:
       S = SwitchStmt::CreateEmpty(
           Context,
           /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
           /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
       break;
 

clang/lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
   VisitStmt(S);
 
   bool HasElse = S->getElse() != nullptr;
   bool HasVar = S->getConditionVariableDeclStmt() != nullptr;
   bool HasInit = S->getInit() != nullptr;
 
-  Record.push_back(S->isConstexpr());
   Record.push_back(HasElse);
   Record.push_back(HasVar);
   Record.push_back(HasInit);
-
+  Record.push_back(static_cast<uint64_t>(S->getStatementKind()));
   Record.AddStmt(S->getCond());
   Record.AddStmt(S->getThen());
   if (HasElse)
     Record.AddStmt(S->getElse());
   if (HasVar)
     Record.AddDeclRef(S->getConditionVariable());
   if (HasInit)
     Record.AddStmt(S->getInit());

clang/lib/StaticAnalyzer/Checkers/LocalizationChecker.cpp

if (MatchingStatements.back() != nullptr) {
       return true;
     }
   }
   InMatchingStatement = false;
   return true;
 }
 
 bool PluralMisuseChecker::MethodCrawler::VisitIfStmt(const IfStmt *I) {
-  const Expr *Condition = I->getCond()->IgnoreParenImpCasts();
+  const Expr *Condition = I->getCond();
+  if (!Condition)
+    return true;
+  Condition = Condition->IgnoreParenImpCasts();
   if (isCheckingPlurality(Condition)) {
     MatchingStatements.push_back(I);
     InMatchingStatement = true;
   } else {
     MatchingStatements.push_back(nullptr);
     InMatchingStatement = false;
   }
 

clang/test/AST/Interp/if_consteval.cpp

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fexperimental-new-constant-interpreter %s -verify
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only %s -verify
+// expected-no-diagnostics
+
+constexpr void f() {
+  int i = 0;
+  if consteval {
+    i = 1;
+  }
+  else {
+    i = 2;
+  }
+
+  if consteval {
+    i = 1;
+  }
+
+  if !consteval {
+    i = 1;
+  }
+
+  if !consteval {
+    i = 1;
+  }
+  else {
+    i = 1;
+  }
+}

clang/test/AST/ast-dump-if-json.cpp

-// RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++17 -ast-dump=json %s | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++2b -ast-dump=json %s | FileCheck %s
 
 void func(int val) {
   if (val)
     ;
 
   if (val)
     ;
   else
void func(int val) {
   if constexpr(10 == 10)
     ;
 
   if (int i = 12)
     ;
 
   if (int i = 12; i)
     ;
+
+  if consteval {}
+
+  if consteval {} else {}
+
+  if not consteval {}
+
+  if not consteval {} else {}
 }
 
 // NOTE: CHECK lines have been autogenerated by gen_ast_dump_json_test.py
 // using --filters=IfStmt
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 111,
 // CHECK-NEXT:    "line": 4,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:      "col": 5,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    }
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 129,
 // CHECK-NEXT:    "line": 7,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:      "col": 5,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    }
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 160,
 // CHECK-NEXT:    "line": 12,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:       }
 // CHECK-NEXT:      }
 // CHECK-NEXT:     }
 // CHECK-NEXT:    ]
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 213,
 // CHECK-NEXT:    "line": 19,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:      "col": 5,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    }
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 245,
 // CHECK-NEXT:    "line": 22,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:      "col": 5,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    }
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
 
+
 // CHECK:  "kind": "IfStmt",
 // CHECK-NEXT:  "range": {
 // CHECK-NEXT:   "begin": {
 // CHECK-NEXT:    "offset": 270,
 // CHECK-NEXT:    "line": 25,
 // CHECK-NEXT:    "col": 3,
 // CHECK-NEXT:    "tokLen": 2
 // CHECK-NEXT:   },

 // CHECK-NEXT:      "offset": 293,
 // CHECK-NEXT:      "col": 5,
 // CHECK-NEXT:      "tokLen": 1
 // CHECK-NEXT:     }
 // CHECK-NEXT:    }
 // CHECK-NEXT:   }
 // CHECK-NEXT:  ]
 // CHECK-NEXT: }
+
+
+// CHECK:  "kind": "IfStmt",
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {
+// CHECK-NEXT:    "offset": 298,
+// CHECK-NEXT:    "line": 28,
+// CHECK-NEXT:    "col": 3,
+// CHECK-NEXT:    "tokLen": 2
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "end": {
+// CHECK-NEXT:    "offset": 312,
+// CHECK-NEXT:    "col": 17,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "isConsteval": true,
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 311,
+// CHECK-NEXT:      "col": 16,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 312,
+// CHECK-NEXT:      "col": 17,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }
+
+
+// CHECK:  "kind": "IfStmt",
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {
+// CHECK-NEXT:    "offset": 317,
+// CHECK-NEXT:    "line": 30,
+// CHECK-NEXT:    "col": 3,
+// CHECK-NEXT:    "tokLen": 2
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "end": {
+// CHECK-NEXT:    "offset": 339,
+// CHECK-NEXT:    "col": 25,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "hasElse": true,
+// CHECK-NEXT:  "isConsteval": true,
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 330,
+// CHECK-NEXT:      "col": 16,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 331,
+// CHECK-NEXT:      "col": 17,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 338,
+// CHECK-NEXT:      "col": 24,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 339,
+// CHECK-NEXT:      "col": 25,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }
+
+
+// CHECK:  "kind": "IfStmt",
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {
+// CHECK-NEXT:    "offset": 344,
+// CHECK-NEXT:    "line": 32,
+// CHECK-NEXT:    "col": 3,
+// CHECK-NEXT:    "tokLen": 2
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "end": {
+// CHECK-NEXT:    "offset": 362,
+// CHECK-NEXT:    "col": 21,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "isConsteval": true,
+// CHECK-NEXT:  "constevalIsNegated": true,
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 361,
+// CHECK-NEXT:      "col": 20,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 362,
+// CHECK-NEXT:      "col": 21,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }
+
+
+// CHECK:  "kind": "IfStmt",
+// CHECK-NEXT:  "range": {
+// CHECK-NEXT:   "begin": {
+// CHECK-NEXT:    "offset": 367,
+// CHECK-NEXT:    "line": 34,
+// CHECK-NEXT:    "col": 3,
+// CHECK-NEXT:    "tokLen": 2
+// CHECK-NEXT:   },
+// CHECK-NEXT:   "end": {
+// CHECK-NEXT:    "offset": 393,
+// CHECK-NEXT:    "col": 29,
+// CHECK-NEXT:    "tokLen": 1
+// CHECK-NEXT:   }
+// CHECK-NEXT:  },
+// CHECK-NEXT:  "hasElse": true,
+// CHECK-NEXT:  "isConsteval": true,
+// CHECK-NEXT:  "constevalIsNegated": true,
+// CHECK-NEXT:  "inner": [
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 384,
+// CHECK-NEXT:      "col": 20,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 385,
+// CHECK-NEXT:      "col": 21,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   },
+// CHECK-NEXT:   {
+// CHECK-NEXT:    "id": "0x{{.*}}",
+// CHECK-NEXT:    "kind": "CompoundStmt",
+// CHECK-NEXT:    "range": {
+// CHECK-NEXT:     "begin": {
+// CHECK-NEXT:      "offset": 392,
+// CHECK-NEXT:      "col": 28,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     },
+// CHECK-NEXT:     "end": {
+// CHECK-NEXT:      "offset": 393,
+// CHECK-NEXT:      "col": 29,
+// CHECK-NEXT:      "tokLen": 1
+// CHECK-NEXT:     }
+// CHECK-NEXT:    }
+// CHECK-NEXT:   }
+// CHECK-NEXT:  ]
+// CHECK-NEXT: }

clang/test/AST/ast-dump-stmt.cpp

 // Test without serialization:
-// RUN: %clang_cc1 -std=c++2a -triple x86_64-linux-gnu -fcxx-exceptions -ast-dump %s \
+// RUN: %clang_cc1 -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -ast-dump %s \
 // RUN: | FileCheck -strict-whitespace %s
 //
 // Test with serialization:
-// RUN: %clang_cc1 -std=c++2a -triple x86_64-linux-gnu -fcxx-exceptions -emit-pch -o %t %s
-// RUN: %clang_cc1 -x c++ -std=c++2a -triple x86_64-linux-gnu -fcxx-exceptions -include-pch %t -ast-dump-all /dev/null \
+// RUN: %clang_cc1 -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -emit-pch -o %t %s
+// RUN: %clang_cc1 -x c++ -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -include-pch %t -ast-dump-all /dev/null \
 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
 // RUN: | FileCheck -strict-whitespace %s
 
 namespace n {
 void function() {}
 int Variable;
 }
 using n::function;
void TestIf(bool b) {
   // CHECK-NEXT: BinaryOperator
   // CHECK-NEXT: UnaryExprOrTypeTraitExpr
   // CHECK-NEXT: ParenExpr
   // CHECK-NEXT: DeclRefExpr
   // CHECK-NEXT: ImplicitCastExpr
   // CHECK-NEXT: IntegerLiteral
   // CHECK-NEXT: NullStmt
   // CHECK-NEXT: NullStmt
+
+  if consteval {}
+  // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:17> consteval
+  // CHECK-NEXT: CompoundStmt
+
+  if ! consteval {}
+  else {}
+  // CHECK: IfStmt 0x{{[^ ]*}} <line:[[@LINE-2]]:3, line:[[@LINE-1]]:9> has_else !consteval
+  // CHECK-NEXT: CompoundStmt
+  // CHECK-NEXT: CompoundStmt
 }
 
 struct Container {
   int *begin() const;
   int *end() const;
 };
 
 void TestIteration() {

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp

+// RUN: %clang_cc1 -std=c++2b -verify %s
+
+void test_consteval() {
+  if consteval ({(void)1;});  // expected-error {{expected { after consteval}}
+  if consteval (void) 0; // expected-error {{expected { after consteval}}
+  if consteval {
+    (void)0;
+  } else (void)0; // expected-error {{expected { after else}}
+
+  static_assert([] {
+    if consteval {
+      return 0;
+    }
+    return 1;
+  }() == 0);
+
+  static_assert([] {
+    if consteval {
+      return 0;
+    } else {
+      return 1;
+    }
+  }() == 0);
+
+  static_assert([] {
+    if !consteval {
+      return 0;
+    } else {
+      return 1;
+    }
+  }() == 1);
+
+  static_assert([] {
+    if not consteval {
+      return 0;
+    }
+    return 1;
+  }() == 1);
+
+  if consteval [[likely]] { // expected-warning {{attribute 'likely' has no effect when annotating an 'if consteval' statement}}\
+                            // expected-note 2{{annotating the 'if consteval' statement here}}
+
+
+  }
+  else [[unlikely]] { // expected-warning {{attribute 'unlikely' has no effect when annotating an 'if consteval' statement}}
+
+  }
+
+}
+
+void test_consteval_jumps() {
+  if consteval { // expected-note 4{{jump enters controlled statement of consteval if}}
+    goto a;
+    goto b; // expected-error {{cannot jump from this goto statement to its label}}
+  a:;
+  } else {
+    goto b;
+    goto a; // expected-error {{cannot jump from this goto statement to its label}}
+  b:;
+  }
+  goto a; // expected-error {{cannot jump from this goto statement to its label}}
+  goto b; // expected-error {{cannot jump from this goto statement to its label}}
+}
+
+void test_consteval_switch() {
+  int x = 42;
+  switch (x) {
+    if consteval { // expected-note 2{{jump enters controlled statement of consteval if}}
+    case 1:;       // expected-error {{cannot jump from switch statement to this case label}}
+    default:;      // expected-error {{cannot jump from switch statement to this case label}}
+    } else {
+    }
+  }
+  switch (x) {
+    if consteval { // expected-note 2{{jump enters controlled statement of consteval if}}
+    } else {
+    case 2:;  // expected-error {{cannot jump from switch statement to this case label}}
+    default:; // expected-error {{cannot jump from switch statement to this case label}}
+    }
+  }
+}
+
+consteval int f(int i) { return i; }
+constexpr int g(int i) {
+  if consteval {
+    return f(i);
+  } else {
+    return 42;
+  }
+}
+static_assert(g(10) == 10);
+
+constexpr int h(int i) { // expected-note {{declared here}}
+  if !consteval {
+    return f(i); // expected-error {{call to consteval function 'f' is not a constant expression}}\
+                     // expected-note  {{cannot be used in a constant expression}}
+  }
+  return 0;
+}
+
+consteval void warn_in_consteval() {
+  if consteval { // expected-warning {{consteval if is always true in an immediate context}}
+    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+  }
+}
+
+constexpr void warn_in_consteval2() {
+  if consteval {
+    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+  }
+}
+
+auto y = []() consteval {
+  if consteval { // expected-warning {{consteval if is always true in an immediate context}}
+    if consteval {} // expected-warning {{consteval if is always true in an immediate context}}
+  }
+};
+
+namespace test_transform {
+int f(auto n) {
+  if consteval {
+    n.foo; //expected-error {{no member named}}
+  }
+  else {
+  }
+
+  if !consteval {
+    n.foo; //expected-error {{no member named}}
+  }
+  else {
+  }
+
+  return 0;
+}
+
+constexpr int g(auto n) {
+  if consteval {
+  }
+  else {
+    n.foo; //expected-error {{no member named}}
+  }
+
+  if !consteval {
+  }
+  else {
+     n.foo; //expected-error {{no member named}}
+  }
+
+  return 0;
+}
+
+struct S {};
+void test() {
+  f(S{}); //expected-note {{in instantiation}}
+  g(S{}); //expected-note {{in instantiation}}
+}
+
+}

clang/test/CodeGenCXX/cxx2b-consteval-if.cpp

+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -o - | FileCheck %s
+
+void should_be_used_1();
+void should_be_used_2();
+void should_be_used_3();
+constexpr void should_not_be_used() {}
+
+constexpr void f() {
+  if consteval {
+    should_not_be_used(); // CHECK-NOT: call {{.*}}should_not_be_used
+  } else {
+    should_be_used_1();  // CHECK: call {{.*}}should_be_used_1
+  }
+
+  if !consteval {
+    should_be_used_2();  // CHECK: call {{.*}}should_be_used_2
+  }
+
+  if !consteval {
+    should_be_used_3();  // CHECK: call {{.*}}should_be_used_3
+  } else {
+    should_not_be_used(); // CHECK-NOT: call {{.*}}should_not_be_used
+  }
+}
+
+void g() {
+  f();
+}