Implement P1401R5

[cor3ntin]

Summary

Support Narrowing conversions to bool in if constexpr condition
under C++23 language mode.

Only if constexpr is implemented as the behavior of static_assert
is already conforming.

[mizvekov]

clang/lib/Sema/SemaExprCXX.cpp

3940

Minor nit: I think it would be a tiny bit clearer if you factored out this condition, since you repeat it:

bool IsConstexprNonValueDependent = IsConstexpr  && !CondExpr->isValueDependent();
if (!LangOpts.CPlusPlus2b && IsConstexprNonValueDependent) {
....
if (!IsConstexprNonValueDependent)

3945

The value returned from PerformContextuallyConvertToBool can have a possibly failed state (We follow this convention for FooResult named types).
But here there is a get on it on a path where there could be an error.
Can you handle this, and also add test case to cover it?

[cor3ntin]

Fix and add tests for the case where the condition is not convertible to bool
Simplify code.
Add reference to c++23 wording

[cor3ntin]

Fix formatting

[mizvekov]

Thanks!
Just some nits and some minor points on the tests.

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

Looks a bit easier to parse the english there.

clang/lib/Sema/SemaExprCXX.cpp

3932–3933

This FIXME got pushed out of the thing it used to refer to.

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

1–3

I think attaching the expected diagnostics to the lines that generate them looks clearer and is easier to maintain.

The problem is that it seems you are having to work around that some of these errors are conditional on the std version, and it would indeed be quite a bite noisier with the preprocessor there, but there is a simple solution: with the suggested edit above, you can do things like:

`
// cxx17-error {{value of type 'ccce::S' is not implicitly convertible to 'bool'}}
// cxx2b-error {{value of type 'ccce::S' is not contextually convertible to 'bool'}}
`

But you can still do expected-note {{cannot be used in a constant expression}} in order to expect diagnostics for all versions.

41

This is not consistently indented.

70–71

Hmm what is this testing exactly? That constexprS is not getting confused with s?

[cor3ntin]

Improve and fix test,
Move the fixme in a more sensible place

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

I would rather not change that, to remain consistent with existing diagnostics involving constexpr if
But I agree it might be good to change them all

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

1–3

Thanks, much better, I did not know it was an option

41

Unfortunately, it was put there by clang-format, should I move it manually?

70–71

Indeed, will fix

[mizvekov]

So I read the paper, downloaded this patch, played around with it a little bit, tried some different tests, like expressions with dependent types,
classes with regular/explicit user-defined conversions, function names and some other examples that are mentioned in the paper.
It works fine on these.

However, I confirm that the failures in CXX/except/except.spec/p1.cpp detected by the buildbots are real.
It fails for me with this DR, works on parent revision.

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

I see, yeah agreed.

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

41

In general you should respect the formatting tips you get from the non-test code, as these will fail the pre-merge checks.
But in the test code, our buildbot produces the clang-format patch but this is not really enforced when merging.

I think what you are doing here, keeping the existing style, is reasonable so you should disregard this particular tip from the format patch.
The other option would be to format everything in a pre-work NFC commit. This should be fine for pure semantic tests like these, but you have to be careful with parser tests.

[cor3ntin]

In D105127#2850975, @mizvekov wrote:

So I read the paper, downloaded this patch, played around with it a little bit, tried some different tests, like expressions with dependent types,
classes with regular/explicit user-defined conversions, function names and some other examples that are mentioned in the paper.
It works fine on these.

However, I confirm that the failures in CXX/except/except.spec/p1.cpp detected by the buildbots are real.
It fails for me with this DR, works on parent revision.

Yep, I need to look at that. I've ran the entire test suite locally without issue initially but maybe I broke something!

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

41

This is unfortunate, but I'll fix it, thanks!

[mizvekov]

Its unfortunate the buildbot does not have debug symbols.

If you have not managed to reproduce it locally, here is the backtrace I got:

FAIL: Clang :: CXX/except/except.spec/p1.cpp (1 of 1)
******************** TEST 'Clang :: CXX/except/except.spec/p1.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   c:\users\mizve\source\llvm\build\dbg\bin\clang.exe -cc1 -internal-isystem c:\users\mizve\source\llvm\build\dbg\lib\clang\13.0.0\include -nostdsysteminc -std=c++11 -fexceptions -fcxx-exceptions -fsyntax-only -verify C:\Users\mizve\source\llvm\clang\test\CXX\except\except.spec\p1.cpp
--
Exit Code: 2147483651

Command Output (stdout):
--
$ ":" "RUN: at line 1"
$ "c:\users\mizve\source\llvm\build\dbg\bin\clang.exe" "-cc1" "-internal-isystem" "c:\users\mizve\source\llvm\build\dbg\lib\clang\13.0.0\include" "-nostdsysteminc" "-std=c++11" "-fexceptions" "-fcxx-exceptions" "-fsyntax-only" "-verify" "C:\Users\mizve\source\llvm\clang\test\CXX\except\except.spec\p1.cpp"
# command stderr:
Assertion failed: (NoexceptExpr->isTypeDependent() || NoexceptExpr->getType()->getCanonicalTypeUnqualified() == Context.BoolTy) && "Parser should have made sure that the expression is boolean", file C:\Users\mizve\source\llvm\clang\lib\Sema\SemaDeclCXX.cpp, line 17947
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.      Program arguments: c:\\users\\mizve\\source\\llvm\\build\\dbg\\bin\\clang.exe -cc1 -internal-isystem c:\\users\\mizve\\source\\llvm\\build\\dbg\\lib\\clang\\13.0.0\\include -nostdsysteminc -std=c++11 -fexceptions -fcxx-exceptions -fsyntax-only -verify C:\\Users\\mizve\\source\\llvm\\clang\\test\\CXX\\except\\except.spec\\p1.cpp
1.      <eof> parser at end of file
2.      C:\Users\mizve\source\llvm\clang\test\CXX\except\except.spec\p1.cpp:75:1: parsing namespace 'PR11084'
3.      C:\Users\mizve\source\llvm\clang\test\CXX\except\except.spec\p1.cpp:76:19: parsing struct/union/class body 'PR11084::A'
 #0 0x00007ff72b447a6c HandleAbort C:\Users\mizve\source\llvm\llvm\lib\Support\Windows\Signals.inc:408:0
 #1 0x00007ffff838bc31 (C:\Windows\SYSTEM32\ucrtbased.dll+0x6bc31)
 #2 0x00007ffff838d889 (C:\Windows\SYSTEM32\ucrtbased.dll+0x6d889)
 #3 0x00007ffff83930bf (C:\Windows\SYSTEM32\ucrtbased.dll+0x730bf)
 #4 0x00007ffff8391091 (C:\Windows\SYSTEM32\ucrtbased.dll+0x71091)
 #5 0x00007ffff8393a1f (C:\Windows\SYSTEM32\ucrtbased.dll+0x73a1f)
 #6 0x00007ff72fe2bf2a clang::Sema::checkExceptionSpecification(bool, enum clang::ExceptionSpecificationType, class llvm::ArrayRef<class clang::OpaquePtr<class clang::QualType>>, class llvm::ArrayRef<class clang::SourceRange>, class clang::Expr *, class llvm::SmallVectorImpl<class clang::QualType> &, struct clang::FunctionProtoType::ExceptionSpecInfo &) C:\Users\mizve\source\llvm\clang\lib\Sem #7 0x00007ff72fe2c0ee clang::Sema::actOnDelayedExceptionSpecification(class clang::Decl *, enum clang::ExceptionSpecificationType, class clang::SourceRange, class llvm::ArrayRef<class clang::OpaquePtr<class clang::QualType>>, class llvm::ArrayRef<class clang::SourceRange>, class clang::Expr *) C:\Users\mizve\source\llvm\clang\lib\Sema\SemaDeclCXX.cpp:17983:0
 #8 0x00007ff72fb16bd9 clang::Parser::ParseLexedMethodDeclaration(struct clang::Parser::LateParsedMethodDeclaration &) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseCXXInlineMethods.cpp:489:0
ng\lib\Parse\ParseCXXInlineMethods.cpp:257:0
#10 0x00007ff72fb15eb6 clang::Parser::ParseLexedMethodDeclarations(struct clang::Parser::ParsingClass &) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseCXXInlineMethods.cpp:325:0
#11 0x00007ff72fb96995 clang::Parser::ParseCXXMemberSpecification(class clang::SourceLocation, class clang::SourceLocation, struct clang::ParsedAttributesWithRange &, unsigned int, class clang::Decl *) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDeclCXX.cpp:35#12 0x00007ff72fb95153 clang::Parser::ParseClassSpecifier(enum clang::tok::TokenKind, class clang::SourceLocation, class clang::DeclSpec &, struct clang::Parser::ParsedTemplateInfo const &, enum clang::AccessSpecifier, bool, enum clang::Parser::DeclSpecContext, struct clang::ParsedAttributesWithRange &) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDeclCXX.cpp:2030:0
#13 0x00007ff72fad24d2 clang::Parser::ParseDeclarationSpecifiers(class clang::DeclSpec &, struct clang::Parser::ParsedTemplateInfo const &, enum clang::AccessSpecifier, enum clang::Parser::DeclSpecContext, class clang::Parser::LateParsedAttrList *) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDecl.cpp:3989:0
#14 0x00007ff72fb07c7f clang::Parser::ParseSingleDeclarationAfterTemplate(enum clang::DeclaratorContext, struct clang::Parser::ParsedTemplateInfo const &, class clang::ParsingDeclRAIIObject &, class clang::SourceLocation &, class clang::ParsedAttributes &, enum clang::AccessSpecifier) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseTemplate.cpp:225:0
#15 0x00007ff72fb078fa clang::Parser::ParseTemplateDeclarationOrSpecialization(enum clang::DeclaratorContext, class clang::SourceLocation &, class clang::ParsedAttributes &, enum clang::AccessSpecifier) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseTemplate.cpp:169:0
#16 0x00007ff72fb07297 clang::Parser::ParseDeclarationStartingWithTemplate(enum clang::DeclaratorContext, class clang::SourceLocation &, class clang::ParsedAttributes &, enum clang::AccessSpecifier) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseTemplate.cpp:46:0
#17 0x00007ff72faca50a clang::Parser::ParseDeclaration(enum clang::DeclaratorContext, class clang::SourceLocation &, struct clang::ParsedAttributesWithRange &, class clang::SourceLocation *) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDecl.cpp:1718:0
#18 0x00007ff72fa84fc9 clang::Parser::ParseExternalDeclaration(struct clang::ParsedAttributesWithRange &, class clang::ParsingDeclSpec *) C:\Users\mizve\source\llvm\clang\lib\Parse\Parser.cpp:907:0
#19 0x00007ff72fb8eff8 clang::Parser::ParseInnerNamespace(class llvm::SmallVector<struct clang::Parser::InnerNamespaceInfo, 4> const &, unsigned int, class clang::SourceLocation &, class clang::ParsedAttributes &, class clang::BalancedDelimiterTracker &) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDeclCXX.cpp:247:0
#20 0x00007ff72fb8ede0 clang::Parser::ParseNamespace(enum clang::DeclaratorContext, class clang::SourceLocation &, class clang::SourceLocation) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDeclCXX.cpp:227:0
#21 0x00007ff72faca6ea clang::Parser::ParseDeclaration(enum clang::DeclaratorContext, class clang::SourceLocation &, struct clang::ParsedAttributesWithRange &, class clang::SourceLocation *) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseDecl.cpp:1731:0
#22 0x00007ff72fa84fc9 clang::Parser::ParseExternalDeclaration(struct clang::ParsedAttributesWithRange &, class clang::ParsingDeclSpec *) C:\Users\mizve\source\llvm\clang\lib\Parse\Parser.cpp:907:0
#23 0x00007ff72fa7fd34 clang::Parser::ParseTopLevelDecl(class clang::OpaquePtr<class clang::DeclGroupRef> &, bool) C:\Users\mizve\source\llvm\clang\lib\Parse\Parser.cpp:719:0
#24 0x00007ff72fa7c078 clang::ParseAST(class clang::Sema &, bool, bool) C:\Users\mizve\source\llvm\clang\lib\Parse\ParseAST.cpp:158:0
#25 0x00007ff72c913df7 clang::ASTFrontendAction::ExecuteAction(void) C:\Users\mizve\source\llvm\clang\lib\Frontend\FrontendAction.cpp:1060:0
#26 0x00007ff72c9137ae clang::FrontendAction::Execute(void) C:\Users\mizve\source\llvm\clang\lib\Frontend\FrontendAction.cpp:955:0
#27 0x00007ff72c8944a6 clang::CompilerInstance::ExecuteAction(class clang::FrontendAction &) C:\Users\mizve\source\llvm\clang\lib\Frontend\CompilerInstance.cpp:974:0
#28 0x00007ff72cafc037 clang::ExecuteCompilerInvocation(class clang::CompilerInstance *) C:\Users\mizve\source\llvm\clang\lib\FrontendTool\ExecuteCompilerInvocation.cpp:278:0
#29 0x00007ff726c93e04 cc1_main(class llvm::ArrayRef<char const *>, char const *, void *) C:\Users\mizve\source\llvm\clang\tools\driver\cc1_main.cpp:246:0
#30 0x00007ff726c7fa40 ExecuteCC1Tool C:\Users\mizve\source\llvm\clang\tools\driver\driver.cpp:338:0
#31 0x00007ff726c8032b main C:\Users\mizve\source\llvm\clang\tools\driver\driver.cpp:415:0
#32 0x00007ff7325e7a99 invoke_main d:\agent\_work\36\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:79:0
#33 0x00007ff7325e793e __scrt_common_main_seh d:\agent\_work\36\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:288:0
#34 0x00007ff7325e77fe __scrt_common_main d:\agent\_work\36\s\src\vctools\crt\vcstartup\src\startup\exe_common.inl:331:0
#35 0x00007ff7325e7b2e mainCRTStartup d:\agent\_work\36\s\src\vctools\crt\vcstartup\src\startup\exe_main.cpp:17:0
#36 0x00007ff87d467034 (C:\Windows\System32\KERNEL32.DLL+0x17034)
#37 0x00007ff87d5a2651 (C:\Windows\SYSTEM32\ntdll.dll+0x52651)

error: command failed with exit status: 2147483651

[cor3ntin]

In D105127#2850975, @mizvekov wrote:

So I read the paper, downloaded this patch, played around with it a little bit, tried some different tests, like expressions with dependent types,
classes with regular/explicit user-defined conversions, function names and some other examples that are mentioned in the paper.
It works fine on these.

However, I confirm that the failures in CXX/except/except.spec/p1.cpp detected by the buildbots are real.
It fails for me with this DR, works on parent revision.

Yep, I need to look at that. I've ran the entire test suite locally without issue initially but maybe I broke something!

In D105127#2851049, @mizvekov wrote:

Its unfortunate the buildbot does not have debug symbols.

If you have not managed to reproduce it locally, here is the backtrace I got:

Thanks.
I think my local build had NDEBUG defined, so an assert was not firing
My current guess is that early exiting on value-dependent expressions bypasses check expected down the line, so I'll confirm that, fix it and update the PR!
Thanks for your help!

[cor3ntin]

Fix Formatting in tests.

Do not return early for value dependent expressions
as PerformContextuallyConvertToBool performs checks that
are expected to occur down the line

[mizvekov]

LGTM!

Since you submitted this quite recently, I would wait some more time before landing, for any other people who might want to review this.
Maybe wait for it to be a week old, ping anyone else you might want to get a review from, and wait a couple of days for them to respond.

clang/lib/Sema/SemaExprCXX.cpp

3940

By the way you fixed this by reverting back to the original form pre-refactoring, so my tip above applies again.

[rsmith]

P1401R5 points out that we get noexcept(bool) wrong in the opposite direction, permitting conversions to bool that we are supposed to reject. While that rule didn't change as part of P1401R5, it'd be nice to handle it as part of dealing with that paper.

clang/lib/Sema/SemaExprCXX.cpp

3934

I think we should apply this retroactively, even though it wasn't moved as a DR. All other implementations already behave this way across all language modes, and it's just not reasonable to reject conversions in the condition of an if constexpr that are accepted in the condition of an if -- this seems like an obvious language defect even if the C++ committee haven't officially voted it to be one yet.

Separately I've asked on the committee reflectors if we can officially treat this as a DR, given the implementation consensus.

3940

Please use E.isInvalid() instead of !E.isUsable() unless you anticipate and intend to handle the valid-but-null case (which is unusable but not invalid).

[rsmith]

Would we benefit from any more test coverage for the static_assert side of this paper, or is our (formerly wrong and now correct) behavior already well-covered by existing tests? (Similarly for explicit(bool), do we already have good test coverage for the distinction between "contextually converted constant expression of type bool" and the various other possible rules?)

[rsmith]

In D105127#2851443, @rsmith wrote:

P1401R5 points out that we get noexcept(bool) wrong in the opposite direction, permitting conversions to bool that we are supposed to reject. While that rule didn't change as part of P1401R5, it'd be nice to handle it as part of dealing with that paper.

To be clear: doing that as a separate change is completely fine, but we should make sure we don't forget about it!

[rsmith]

clang/www/cxx_status.html

1299

This should be class unreleased (yellow) for now so that people can easily tell what's in the most recent Clang release versus what's implemented but not released; we convert all the class="unreleased" to class="full" when we cut a release.

[cor3ntin]

Mark the feature as unreleased

[cor3ntin]

Replace !isUsable() by isInvalid()

[cor3ntin]

clang/lib/Sema/SemaExprCXX.cpp

3934

I'll do that - it might take me a few days to get to it though

[cor3ntin]

clang/www/cxx_status.html

1299

Would you prefer I mark it partial for the explicit bool case?

[cor3ntin]

• Apply the change to all C++ version
• Add more tests for static_assert

[cor3ntin]

clang-format

[rsmith]

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

Would it be reasonable to drop the "convertible to bool" part here? We know the problem is that the (converted) expression is not a constant expression, not that the expression can't be converted to bool, because we handle the conversion to bool separately before we get to this diagnostic; I think the diagnostic would be clearer if it didn't mention the conversion.

clang/www/cxx_status.html

1299

If you're not planning on working on explicit(bool) yourself, then I think marking it as "partial" might be useful as a reminder that we should go back and look at that paper again. Otherwise, I have no strong preference.

[cor3ntin]

Mark the feature completion as partial
as this PR does not fix explicit(bool)

[mizvekov]

clang/test/SemaCXX/static-assert.cpp

202

Missing newline here. You might need to configure your editor to always add this.

[cor3ntin]

Missing EOL

[cor3ntin]

Rebase

[aaron.ballman]

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

+1 -- I think the "convertible to bool" may trip some users up on how to correct the issue.

clang/lib/Sema/SemaExprCXX.cpp

3925

3932–3933

+1, I think this comment should move down to the APSInt declaration so it's clear which value we want returned to the caller someday.

3935

[aaron.ballman]

Making it clear that there are still some minor changes left to be made.

[cor3ntin]

Improve diagnostic message, fix comments, use isInvalid instead of isUsable

[cor3ntin]

clang/include/clang/Basic/DiagnosticSemaKinds.td

1491

Sorry, I missed that feedback earlier, fixed now

[aaron.ballman]

This LGTM aside from a small nit, but you should wait a bit to land in case other reviewers have comments.

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

42–43

This looks like it still needs some indentation to match the nearby local style. Also, do you need to declare the variable s?

[aaron.ballman]

Oops, I chanted the magic incantation but forgot to press the button. LGTM again. ;-)

[cor3ntin]

Fix test formatting

[aaron.ballman]

Thanks for the patch! I've committed on your behalf in 8747234032c9c6270a6198ab3cca14ce2bd18721.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_converted_constant_expression : Error<
   "value of type %0 is not implicitly convertible to %1">;
 def err_typecheck_converted_constant_expression_disallowed : Error<
   "conversion from %0 to %1 is not allowed in a converted constant expression">;
 def err_typecheck_converted_constant_expression_indirect : Error<
   "conversion from %0 to %1 in converted constant expression would "
   "bind reference to a temporary">;
 def err_expr_not_cce : Error<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|constexpr if condition|explicit specifier argument}0 "
+  "array size|explicit specifier argument}0 "
   "is not a constant expression">;
 def ext_cce_narrowing : ExtWarn<
   "%select{case value|enumerator value|non-type template argument|"
-  "array size|constexpr if condition|explicit specifier argument}0 "
+  "array size|explicit specifier argument}0 "
   "%select{cannot be narrowed from type %2 to %3|"
   "evaluates to %2, which cannot be narrowed to type %3}1">,
   InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
 def err_ice_not_integral : Error<
   "%select{integer|integral}1 constant expression must have "
   "%select{integer|integral or unscoped enumeration}1 type, not %0">;
 def err_ice_incomplete_type : Error<
   "integral constant expression has incomplete class type %0">;

 def err_messaging_super_with_direct_method : Error<
   "messaging super with a direct method">;
 def err_messaging_class_with_direct_method : Error<
   "messaging a Class with a method that is possibly direct">;
 
 // C++ declarations
 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 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">,

clang/include/clang/Sema/Sema.h

public:
   ExprResult PerformContextuallyConvertToObjCPointer(Expr *From);
 
   /// Contexts in which a converted constant expression is required.
   enum CCEKind {
     CCEK_CaseValue,   ///< Expression in a case label.
     CCEK_Enumerator,  ///< Enumerator value with fixed underlying type.
     CCEK_TemplateArg, ///< Value of a non-type template parameter.
     CCEK_ArrayBound,  ///< Array bound in array declarator or new-expression.
-    CCEK_ConstexprIf, ///< Condition in a constexpr if statement.
     CCEK_ExplicitBool ///< Condition in an explicit(bool) specifier.
   };
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               llvm::APSInt &Value, CCEKind CCE);
   ExprResult CheckConvertedConstantExpression(Expr *From, QualType T,
                                               APValue &Value, CCEKind CCE,
                                               NamedDecl *Dest = nullptr);
 

clang/lib/Sema/SemaExprCXX.cpp

case ConditionKind::Switch:
     return CheckSwitchCondition(StmtLoc, Condition.get());
   }
 
   llvm_unreachable("unexpected condition kind");
 }
 
 /// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid.
 ExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr) {
-  // C++ 6.4p4:
+  // C++11 6.4p4:
   // The value of a condition that is an initialized declaration in a statement
   // other than a switch statement is the value of the declared variable
   // implicitly converted to type bool. If that conversion is ill-formed, the
   // program is ill-formed.
   // The value of a condition that is an expression is the value of the
   // expression, implicitly converted to bool.
   //
+  // C++2b 8.5.2p2
+  // If the if statement is of the form if constexpr, the value of the condition
+  // is contextually converted to bool and the converted expression shall be
+  // a constant expression.
+  //
+
+  ExprResult E = PerformContextuallyConvertToBool(CondExpr);
+  if (!IsConstexpr || E.isInvalid() || E.get()->isValueDependent())
+    return E;
+
   // FIXME: Return this value to the caller so they don't need to recompute it.
-  llvm::APSInt Value(/*BitWidth*/1);
-  return (IsConstexpr && !CondExpr->isValueDependent())
-             ? CheckConvertedConstantExpression(CondExpr, Context.BoolTy, Value,
-                                                CCEK_ConstexprIf)
-             : PerformContextuallyConvertToBool(CondExpr);
+  llvm::APSInt Cond;
+  E = VerifyIntegerConstantExpression(
+      E.get(), &Cond,
+      diag::err_constexpr_if_condition_expression_is_not_constant);
+  return E;
 }
 
 /// Helper function to determine whether this is the (deprecated) C++
 /// conversion from a string literal to a pointer to non-const char or
 /// non-const wchar_t (for narrow and wide string literals,
 /// respectively).
 bool
 Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) {
   // Look inside the implicit cast, if it exists.
   if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From))
     From = Cast->getSubExpr();
 
   // A string literal (2.13.4) that is not a wide string literal can
   // be converted to an rvalue of type "pointer to char"; a wide
   // string literal can be converted to an rvalue of type "pointer
   // to wchar_t" (C++ 4.2p2).

clang/lib/Sema/SemaOverload.cpp

static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
   if (checkPlaceholderForOverload(S, From))
     return ExprError();
 
   // C++1z [expr.const]p3:
   //  A converted constant expression of type T is an expression,
   //  implicitly converted to type T, where the converted
   //  expression is a constant expression and the implicit conversion
   //  sequence contains only [... list of conversions ...].
-  // C++1z [stmt.if]p2:
-  //  If the if statement is of the form if constexpr, the value of the
-  //  condition shall be a contextually converted constant expression of type
-  //  bool.
   ImplicitConversionSequence ICS =
-      CCE == Sema::CCEK_ConstexprIf || CCE == Sema::CCEK_ExplicitBool
+      CCE == Sema::CCEK_ExplicitBool
           ? TryContextuallyConvertToBool(S, From)
           : TryCopyInitialization(S, From, T,
                                   /*SuppressUserConversions=*/false,
                                   /*InOverloadResolution=*/false,
                                   /*AllowObjCWritebackConversion=*/false,
                                   /*AllowExplicit=*/false);
   StandardConversionSequence *SCS = nullptr;
   switch (ICS.getKind()) {

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

 // RUN: %clang_cc1 -std=c++1z -verify %s
 // RUN: %clang_cc1 -std=c++1z -verify %s -DUNDEFINED
 
 #ifdef UNDEFINED
 // "used but not defined" errors don't get produced if we have more interesting
 // errors.
 namespace std_example {
   template <typename T, typename... Rest> void g(T &&p, Rest &&... rs) {
     // use p
     if constexpr(sizeof...(rs) > 0)
       g(rs...);
int f() {
     else if (x()) // expected-note {{here}}
       return x();
     else
       return -x();
   }
 }
 #else
 namespace ccce {
+
+  struct S {
+  };
   void f() {
     if (5) {}
-    if constexpr (5) {} // expected-error {{cannot be narrowed}}
+    if constexpr (5) {
+    }
   }
   template<int N> void g() {
-    if constexpr (N) {} // expected-error {{cannot be narrowed}}
+    if constexpr (N) {
+    }
   }
-  template void g<5>(); // expected-note {{instantiation of}}
+  template void g<5>();
   void h() {
-    if constexpr (4.3) {} // expected-error{{conversion from 'double' to 'bool' is not allowed in a converted constant expression}}
+    if constexpr (4.3) { //expected-warning {{implicit conversion from 'double' to 'bool' changes value}}
+    }
     constexpr void *p = nullptr;
-    if constexpr (p) {} // expected-error{{conversion from 'void *const' to 'bool' is not allowed in a converted constant expression}}
+    if constexpr (p) {
+    }
+  }
+
+  void not_constant(int b, S s) { //  expected-note 2{{declared here}}
+    if constexpr (bool(b)) {      // expected-error {{constexpr if condition is not a constant expression}} expected-note {{cannot be used in a constant expression}}
+    }
+    if constexpr (b) { // expected-error {{constexpr if condition is not a constant expression}} expected-note {{cannot be used in a constant expression}}
+    }
+    if constexpr (s) { // expected-error {{value of type 'ccce::S' is not contextually convertible to 'bool'}}
+    }
+
+    constexpr S constexprS;
+    if constexpr (constexprS) { // expected-error {{value of type 'const ccce::S' is not contextually convertible to 'bool'}}
+    }
   }
 }
 
 namespace generic_lambda {
   // Substituting for T produces a hard error here, even if substituting for
   // the type of x would remove the error.
   template<typename T> void f() {
     [](auto x) {

clang/test/SemaCXX/static-assert.cpp

 
 template <class T>
 void foo4(T t) {
   static_assert(std::is_const<typename T::iterator>::value, "message");
   // expected-error@-1{{type 'int' cannot be used prior to '::' because it has no members}}
 }
 void callFoo4() { foo4(42); }
 // expected-note@-1{{in instantiation of function template specialization 'foo4<int>' requested here}}
+
+static_assert(42, "message");
+static_assert(42.0, "message"); // expected-warning {{implicit conversion from 'double' to 'bool' changes value from 42 to true}}
+constexpr int *p = 0;
+static_assert(p, "message"); // expected-error {{static_assert failed}}
+
+struct NotBool {
+} notBool;
+constexpr NotBool constexprNotBool;
+static_assert(notBool, "message");          // expected-error {{value of type 'struct NotBool' is not contextually convertible to 'bool'}}
+static_assert(constexprNotBool, "message"); // expected-error {{value of type 'const NotBool' is not contextually convertible to 'bool'}}

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Allow duplicate attributes</td>
       <td><a href="https://wg21.link/P2156R1">P2156R1</a></td>
       <td class="unreleased" align="center">Clang 13</td>
     </tr>
     <tr>
       <td>Narrowing contextual conversions to bool</td>
       <td><a href="https://wg21.link/P1401R5">P1401R5</a></td>
-      <td class="none" align="center">No</td>
+      <td class="partial" align="center">Clang 13</td>
     </tr>
     <tr>
       <td>Trimming whitespaces before line splicing</td>
       <td><a href="https://wg21.link/P2223R2">P2223R2</a></td>
       <td class="full" align="center">Yes</td>
     </tr>
     <tr>
       <td>Make declaration order layout mandated</td>