Try contextually converting condition of constexpr if to Boolean value

[ismailp]

Summary

C++1z 6.4.1/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 [...]
C++1z 5.20/p4:
[...] A contextually converted constant expression of type bool is an
expression, contextually converted to bool (Clause4), where the
converted expression is a constant expression and the conversion
sequence contains only the conversions above. [...]

Contextually converting result of an expression e to a Boolean value
requires bool t(e) to be well-formed.

An explicit conversion function is only considered as a user-defined
conversion for direct-initialization, which is essentially what
contextually converted to bool requires.

Also, fixes PR28470.

[rsmith]

Thanks, LGTM.

If you're looking for more issues in this area -- in passing I noticed that we fail to apply the "contextually converted constant expression of type bool" rules properly in the other cases where they apply, either (the operand of static_assert and noexcept).

[rsmith]

test/CodeGenCXX/cxx1z-constexpr-if.cpp

26–29 ↗

(On Diff #70070)

Please also add a test that we reject expressions that are contextually convertible to a bool constant expression but are not contextually converted constant expressions of type bool. Example:

if constexpr (4.3) // ill-formed, boolean conversion not permitted

... and sadly ...

constexpr void *p = nullptr;
if constexpr (p) // ill-formed, boolean conversion not permitted

[ismailp]

• Added more tests

[ismailp]

Thank you for reviewing.

Sure, I'll try to look into those conversions as well.

test/CodeGenCXX/cxx1z-constexpr-if.cpp

2 ↗

(On Diff #70561)

Is there a more elegant way to do this? The previous check didn't seem to work with diagnostics.

[rsmith]

test/CodeGenCXX/cxx1z-constexpr-if.cpp

2 ↗

(On Diff #70561)

Tests for semantic issues should go into test/SemaCXX (organized by category) or test/CXX (organized by section of the standard). In this case, test/CXX/stmt.stmt/stmt.select/stmt.if/p2.cpp is probably the most appropriate place (somewhere in its namespace ccce, perhaps).

[ismailp]

test/CodeGenCXX/cxx1z-constexpr-if.cpp

2 ↗

(On Diff #70561)

Thanks! I've done that, and pushed.

cfe/trunk/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 =
-    TryCopyInitialization(S, From, T,
+      CCE == Sema::CCEK_ConstexprIf
+          ? TryContextuallyConvertToBool(S, From)
+          : TryCopyInitialization(S, From, T,
                                   /*SuppressUserConversions=*/false,
                                   /*InOverloadResolution=*/false,
                                   /*AllowObjcWritebackConversion=*/false,
                                   /*AllowExplicit=*/false);
   StandardConversionSequence *SCS = nullptr;
   switch (ICS.getKind()) {
   case ImplicitConversionSequence::StandardConversion:
     SCS = &ICS.Standard;
     break;
   case ImplicitConversionSequence::UserDefinedConversion:
     // We are converting to a non-class type, so the Before sequence
     // must be trivial.

cfe/trunk/test/CXX/stmt.stmt/stmt.select/stmt.if/p2.cpp

namespace ccce {
   void f() {
     if (5) {}
     if constexpr (5) {} // expected-error {{cannot be narrowed}}
   }
   template<int N> void g() {
     if constexpr (N) {} // expected-error {{cannot be narrowed}}
   }
   template void g<5>(); // expected-note {{instantiation of}}
+  void h() {
+    if constexpr (4.3) {} // expected-error{{conversion from 'double' to 'bool' is not allowed in a converted constant expression}}
+    constexpr void *p = nullptr;
+    if constexpr (p) {} // expected-error{{conversion from 'void *const' to 'bool' is not allowed in a converted constant expression}}
+  }
 }
 
 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) {
       if constexpr (sizeof(T) == 1 && sizeof(x) == 1)

cfe/trunk/test/CodeGenCXX/cxx1z-constexpr-if.cpp

 // RUN: %clang_cc1 -std=c++1z %s -emit-llvm -o - | FileCheck %s --implicit-check-not=should_not_be_used
 
 void should_be_used_1();
 void should_be_used_2();
+void should_be_used_3();
 void should_not_be_used();
+
+struct A {
+  constexpr explicit operator bool() const {
+    return true;
+  }
+};
+
 void f() {
   if constexpr (false)
     should_not_be_used();
   else
     should_be_used_1();
 
   if constexpr (true || ({ label: false; }))
     should_be_used_2();
   else {
     goto foo;
 foo: should_not_be_used();
   }
+  if constexpr (A())
+    should_be_used_3();
+  else
+    should_not_be_used();
 }
 
 // CHECK: should_be_used_1
 // CHECK: should_be_used_2
+// CHECK: should_be_used_3