[c++] Implement P1957R0 - narrowing pointer-to-bool

[lichray]

Summary

This patch implements the Core language part. The
library part may need a version check.

A few details w.r.t. the paper:

• The Annex D wording implies a C++20 change as requested by Core, but this forms a contradiction because that won't be available for US 212 which requests a fix for a DR against C++17. Therefore this patch implements the paper as a DR against C++11 for now.
• This narrowing category does not consider whether the value fits or whether the object to convert from is a literal (MSVC).
• nullptr to bool is not a conversion (although Clang thinks it is), so nullptr is outside the scope of this change.

References:
https://wg21.link/p1957r0

[lichray]

Regenerate the diff in Git, update description, link to paper.

[lichray]

Implemented in 7ef45f45f67.

clang/lib/Sema/SemaInit.cpp

static void DiagnoseNarrowingInInitList(Sema &S,
   switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
                                 ConstantType)) {
   case NK_Not_Narrowing:
   case NK_Dependent_Narrowing:
     // No narrowing occurred.
     return;
 
   case NK_Type_Narrowing:
-    // This was a floating-to-integer conversion, which is always considered a
-    // narrowing conversion even if the value is a constant and can be
-    // represented exactly as an integer.
+    // This was a floating-to-integer conversion or a boolean conversion from a
+    // pointer, which is always considered a narrowing conversion even if the
+    // value is a constant and can be represented exactly as an integer.
     S.Diag(PostInit->getBeginLoc(), NarrowingErrs(S.getLangOpts())
                                         ? diag::ext_init_list_type_narrowing
                                         : diag::warn_init_list_type_narrowing)
         << PostInit->getSourceRange()
         << PreNarrowingType.getLocalUnqualifiedType()
         << EntityType.getLocalUnqualifiedType();
     break;
 

clang/lib/Sema/SemaOverload.cpp

NarrowingKind StandardConversionSequence::getNarrowingKind(
   switch (Second) {
   // 'bool' is an integral type; dispatch to the right place to handle it.
   case ICK_Boolean_Conversion:
     if (FromType->isRealFloatingType())
       goto FloatingIntegralConversion;
     if (FromType->isIntegralOrUnscopedEnumerationType())
       goto IntegralConversion;
     // Boolean conversions can be from pointers and pointers to members
-    // [conv.bool], and those aren't considered narrowing conversions.
-    return NK_Not_Narrowing;
+    // [conv.bool], which are considered narrowing conversions.
+    return NK_Type_Narrowing;
 
   // -- from a floating-point type to an integer type, or
   //
   // -- from an integer type or unscoped enumeration type to a floating-point
   //    type, except where the source is a constant expression and the actual
   //    value after conversion will fit into the target type and will produce
   //    the original value when converted back to the original type, or
   case ICK_Floating_Integral:

clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp

void std_example() {
   unsigned char uc1 = {5};  // OK: no narrowing needed
   unsigned char uc2 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   unsigned int ui1 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   signed int si1 =
     { (unsigned int)-1 };  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   int ii = {2.0};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   float f1 { x };  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   float f2 { 7 };  // OK: 7 can be exactly represented as a float
+  bool b = {"meow"};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   int f(int);
   int a[] =
     { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 }
 
 enum UnscopedEnum {
   EnumVal = 300
 };
void int_to_float() {
   Agg<float> ce1 = { Convert<int>(123456789) }; // expected-error {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}}
   Agg<double> ce2 = { ConvertVar<long long>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}}
 }
 
 // * from an integer type or unscoped enumeration type to an integer type that
 //   cannot represent all the values of the original type, except where the
 //   source is a constant expression and the actual value after conversion will
 //   fit into the target type and will produce the original value when converted
-//   back to the original type.
+//   back to the original type, or
 void shrink_int() {
   // Not a constant expression.
   short s = 1;
   UnscopedEnum e = EnumVal;
   unsigned short us = 1;
   Agg<char> c1 = {s};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   Agg<char> c2 = {e};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   Agg<unsigned short> s1 = {s};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
void shrink_int() {
   Agg<unsigned int> i6 = {-0x80000000L};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
 
   // Bool is also an integer type, but conversions to it are a different AST
   // node.
   Agg<bool> b1 = {0};  // OK
   Agg<bool> b2 = {1};  // OK
   Agg<bool> b3 = {-1};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
 
-  // Conversions from pointers to booleans aren't narrowing conversions.
-  Agg<bool>* ptr = &b1;
-  Agg<bool> b = {ptr};  // OK
-
   Agg<short> ce1 = { Convert<int>(100000) }; // expected-error {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{silence}} expected-warning {{changes value from 100000 to -31072}}
   Agg<char> ce2 = { ConvertVar<short>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{silence}}
 
   // Negative -> larger unsigned type.
   unsigned long long ll1 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
   unsigned long long ll2 = { 1 }; // OK
   unsigned long long ll3 = { s }; // expected-error {{cannot be narrowed from type 'short'}} expected-note {{silence}}
   unsigned long long ll4 = { us }; // OK
   unsigned long long ll5 = { ll }; // expected-error {{cannot be narrowed from type 'long long'}} expected-note {{silence}}
   Agg<unsigned long long> ll6 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
   Agg<unsigned long long> ll7 = { 18446744073709551615ULL }; // OK
   Agg<unsigned long long> ll8 = { __int128(18446744073709551615ULL) + 1 }; // expected-error {{ 18446744073709551616 which cannot be narrowed}} expected-note {{silence}} expected-warning {{changes value}}
   signed char c = 'x';
   unsigned short usc1 = { c }; // expected-error {{non-constant-expression cannot be narrowed from type 'signed char'}} expected-note {{silence}}
   unsigned short usc2 = { (signed char)'x' }; // OK
   unsigned short usc3 = { (signed char)-1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}}
 }
 
+// * from a pointer type or a pointer-to-member type to bool.
+void pointer_to_bool() {
+  Agg<int> obj;
+  Agg<int> *p1 = &obj;
+  constexpr void *p2 = nullptr;
+
+  Agg<bool> b1 = {p1};           // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b2 = {p2};           // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b3 = {&Agg<int>::t}; // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+
+  Agg<bool> b4 = {ConvertVar<int *>()};           // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b5 = {ConvertVar<int Agg<int>::*>()}; // expected-error {{ cannot be narrowed }} expected-note {{silence}}
+}
+
 // Be sure that type- and value-dependent expressions in templates get the error
 // too.
 
 template<int I, typename T>
 void maybe_shrink_int(T t) {
   Agg<short> s1 = {t};  // expected-error {{ cannot be narrowed }} expected-note {{silence}}
   Agg<short> s2 = {I};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
   Agg<T> t2 = {700};  // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}

clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-cxx11-nowarn.cpp

void std_example() {
   unsigned char uc1 = {5};  // OK: no narrowing needed
   unsigned char uc2 = {-1};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   unsigned int ui1 = {-1};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   signed int si1 =
     { (unsigned int)-1 };  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   int ii = {2.0};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   float f1 { x };  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   float f2 { 7 };  // OK: 7 can be exactly represented as a float
+  bool b = {"meow"};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   int f(int);
   int a[] =
     { 2, f(2), f(2.0) };  // OK: the double-to-int conversion is not at the top level
 }
 
 // Test each rule individually.
 
 template<typename T>
void int_to_float() {
   Agg<float> ce1 = { Convert<int>(123456789) }; // expected-warning {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}}
   Agg<double> ce2 = { ConvertVar<long long>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}}
 }
 
 // * from an integer type or unscoped enumeration type to an integer type that
 //   cannot represent all the values of the original type, except where the
 //   source is a constant expression and the actual value after conversion will
 //   fit into the target type and will produce the original value when converted
-//   back to the original type.
+//   back to the original type, or
 void shrink_int() {
   // Not a constant expression.
   short s = 1;
   unsigned short us = 1;
   Agg<char> c1 = {s};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   Agg<unsigned short> s1 = {s};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   Agg<short> s2 = {us};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
 
void shrink_int() {
   Agg<unsigned int> i4 = {-0x80000000L};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
 
   // Bool is also an integer type, but conversions to it are a different AST
   // node.
   Agg<bool> b1 = {0};  // OK
   Agg<bool> b2 = {1};  // OK
   Agg<bool> b3 = {-1};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
 
-  // Conversions from pointers to booleans aren't narrowing conversions.
-  Agg<bool>* ptr = &b1;
-  Agg<bool> b = {ptr};  // OK
-
   Agg<short> ce1 = { Convert<int>(100000) }; // expected-warning {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{silence}} expected-warning {{changes value from 100000 to -31072}}
   Agg<char> ce2 = { ConvertVar<short>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{silence}}
 }
 
+// * from a pointer type or a pointer-to-member type to bool.
+void pointer_to_bool() {
+  Agg<int> obj;
+  Agg<int> *p1 = &obj;
+  constexpr void *p2 = nullptr;
+
+  Agg<bool> b1 = {p1};           // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b2 = {p2};           // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b3 = {&Agg<int>::t}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
+
+  Agg<bool> b4 = {ConvertVar<int *>()};           // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
+  Agg<bool> b5 = {ConvertVar<int Agg<int>::*>()}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
+}
+
 // Be sure that type- and value-dependent expressions in templates get the warning
 // too.
 
 template<int I, typename T>
 void maybe_shrink_int(T t) {
   Agg<short> s1 = {t};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}}
   Agg<short> s2 = {I};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}
   Agg<T> t2 = {700};  // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}}