[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

5942

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

1320

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?

4723–4724

can this be a scoped enum?

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

9132

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

1363

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

1375

Why is this here instead of with the kw_consteval handling?

clang/lib/Sema/SemaStmt.cpp

879–881

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

9132

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

1363

Yup, forgot to remove that

1375

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

9132

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

1377

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

1541

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

1541

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

5942

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

5942

good enough for me for now.

[cor3ntin]

clang/lib/Parse/ParseStmt.cpp

1541

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

1541

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

1541

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

1541

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

2122

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

2131

Same change here.

clang/include/clang/Basic/DiagnosticSemaKinds.td

1505

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

1505

1506

5945

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

1223

[aaron.ballman]

clang/include/clang/AST/Stmt.h

164

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–2095

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

2122

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

clang/include/clang/Basic/DiagnosticSemaKinds.td

1506

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

1223

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

9132

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

715–716

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.

1449

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

1520–1525

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

922–923

929

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

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2758

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

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

148

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–2095

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

1449

See a little bit below

1520–1525

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

929

It just seemed more explicit

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2758

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

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

9132

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

1520–1525

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

924–926

928–930

clang/lib/Serialization/ASTReaderStmt.cpp

2756–2758

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

[cor3ntin]

Fix comment

[cor3ntin]

Adress Aaron's comments

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1520–1525

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

1520–1525

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

[aaron.ballman]

clang/lib/Parse/ParseStmt.cpp

1520–1525

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

1521–1525

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 an if constexpr if or a consteval if or neither.
+    IfStatementKind 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 IfStmtBits.Kind == IfStatementKind::Consteval;
+  }
+  bool isConstexpr() const {
+    return IfStmtBits.Kind == IfStatementKind::Constexpr;
+  }
+
+  bool isNegatedConsteval() const {
+    return IfStmtBits.Kind == IfStatementKind::ConstevalNegated;
+  }
+
+  bool isConstevalOrNegatedConsteval() const {
+    return IfStmtBits.Kind == IfStatementKind::Consteval ||
+           IfStmtBits.Kind == IfStatementKind::ConstevalNegated;
+  }
+
+  void setStatementKind(IfStatementKind Kind) { IfStmtBits.Kind = Kind; }
+
+  IfStatementKind getStatementKind() const { return 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 if consteval
+    // statements, so skip it.
+    return child_range(getTrailingObjects<Stmt *>() +
+                           (isConstevalOrNegatedConsteval() ? thenOffset() : 0),
                        getTrailingObjects<Stmt *>() +
                            numTrailingObjects(OverloadToken<Stmt *>()));
   }
 
   const_child_range children() const {
-    return const_child_range(getTrailingObjects<Stmt *>(),
-                             getTrailingObjects<Stmt *>() +
-                                 numTrailingObjects(OverloadToken<Stmt *>()));
+    // We always store a condition, but there is none for if consteval
+    // statements, so skip it.
+    return const_child_range(
+        getTrailingObjects<Stmt *>() +
+            (isConstevalOrNegatedConsteval() ? thenOffset() : 0),
   }
 
   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_if_consteval_always_true : Warning<
+  "if consteval is always true in an %select{unevaluated|immediate}0 context">,  InGroup<DiagGroup<"redundant-if-consteval">>;
+
 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 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_if_consteval : Note<
+  "jump enters controlled statement of if consteval">;
 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 };
+  enum class ConstexprSpecKind : unsigned {
+    Unspecified,
+    Constexpr,
+    Consteval,
+    Constinit
+  };
+
+  /// In an if statement, this denotes whether the the statement is
+  /// an if constexpr or if consteval statement.
+  enum class IfStatementKind : unsigned {
+    Ordinary,
+    Constexpr,
+    Consteval,
+    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 };

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 an 'if consteval' 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 (auto it = ExprEvalContexts.rbegin(); it != ExprEvalContexts.rend();
+         it++) {
+      if (it->isImmediateFunctionContext())
+        return true;
+      if (it->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 = true;
+    else if (IS->isNegatedConsteval())
+      Cond = false;
+    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->isConsteval())
+    return visitStmt(IS->getThen());
+  if (IS->isNegatedConsteval())
+    return IS->getElse();
+
   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->isConstevalOrNegatedConsteval());
+  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->isConstevalOrNegatedConsteval()) {
+    OS << "if ";
+    if (If->isNegatedConsteval())
+      OS << "!";
+    OS << "consteval";
+    OS << NL;
+    PrintStmt(If->getThen());
+    if (If->getElse()) {
+      Indent();
+      OS << "else";
+      PrintStmt(If->getElse());
+      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->isConstevalOrNegatedConsteval()) {
+    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->isConstevalOrNegatedConsteval() || 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->isConstevalOrNegatedConsteval())
+      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 statement is always the only branch that can
+  // be runtime evaluated
+  if (S.isConstevalOrNegatedConsteval()) {
+    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->isConstevalOrNegatedConsteval()) {
+      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++]   'if' consteval 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) {
+    if (!isa_and_nonnull<class CompoundStmt>(ThenStmt.get())) {
+      Diag(ConstevalLoc, diag::err_expected_after) << "consteval"
+                                                   << "{";
+      return StmtError();
+    }
+    if (!ElseStmt.isUnset() &&
+        !isa_and_nonnull<class CompoundStmt>(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::Consteval;
+
+  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->isConstevalOrNegatedConsteval() ||
+          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->isConstevalOrNegatedConsteval())
+      Diag = diag::note_protected_by_if_consteval;
 
     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->isConstevalOrNegatedConsteval())
       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/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.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:
     if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
       FunctionScopes.back()->PossiblyUnreachableDiags.
         push_back(sema::PossiblyUnreachableDiag(PD, Loc, Stmts));

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::Consteval ||
+      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();
         Diags.Report(IfLoc,
                      diag::note_attribute_has_no_effect_on_if_constexpr_here)
             << SourceRange(IfLoc, LParenLoc.getLocWithOffset(-1));
if (std::get<0>(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 Decl *D = Decl::castFromDeclContext(CurContext);
+      if (D->getAsFunction() && D->getAsFunction()->isConsteval()) {
+        Immediate = true;
+      }
+    }
+    if (isUnevaluatedContext() || Immediate) {
+      Diags.Report(IfLoc, diag::warn_if_consteval_always_true)
+          << (Immediate ? 1 : 0);
+    }
+  }
+
+  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->isConstevalOrNegatedConsteval()) {
     // 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/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) 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);
+}
+
+void test_consteval_jumps() {
+  if consteval { // expected-note 4{{jump enters controlled statement of if consteval}}
+    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 if consteval}}
+    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 if consteval}}
+    } 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 {{if consteval is always true in an immediate context}}
+    if consteval {} // expected-warning {{if consteval is always true in an immediate context}}
+  }
+}
+
+constexpr void warn_in_consteval2() {
+  if consteval {
+    if consteval {} // expected-warning {{if consteval is always true in an immediate context}}
+  }
+}
+
+auto y = []() consteval {
+  if consteval { // expected-warning {{if consteval is always true in an immediate context}}
+    if consteval {} // expected-warning {{if consteval 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}}
+}
+
+}
 No newline at end of file

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();
+}