[clang] [SemaCXX] Implement CWG2627 Bit-fields and narrowing conversions

Author: MitalAshok

clang/docs/ReleaseNotes.rst

@@ -157,6 +157,11 @@ Resolutions to C++ Defect Reports
 - Clang now diagnoses declarative nested-name-specifiers with pack-index-specifiers.
   (`CWG2858: Declarative nested-name-specifiers and pack-index-specifiers <https://cplusplus.github.io/CWG/issues/2858.html>`_).
 
+- Casts from a bit-field to an integral type is now not considered narrowing if the
+  width of the bit-field means that all potential values are in the range
+  of the target type, even if the type of the bit-field is larger.
+  (`CWG2627. Bit-fields and narrowing conversions  <https://cplusplus.github.io/CWG/issues/2627.html>`_).
+
 C Language Changes
 ------------------
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -6253,6 +6253,9 @@ def ext_init_list_variable_narrowing_const_reference : ExtWarn<
 def ext_init_list_constant_narrowing : ExtWarn<
   "constant expression evaluates to %0 which cannot be narrowed to type %1">,
   InGroup<CXX11Narrowing>, DefaultError, SFINAEFailure;
+def ext_bit_field_narrowing : Extension<
+  "narrowing non-constant-expression from %0 bit-field of width %2 to %1 is a C++23 extension">,
+  InGroup<CXX20CompatPedantic>, SFINAEFailure;
 def ext_init_list_constant_narrowing_const_reference : ExtWarn<
   ext_init_list_constant_narrowing.Summary>,
   InGroup<CXX11NarrowingConstReference>, DefaultError, SFINAEFailure;

clang/include/clang/Sema/Overload.h

@@ -244,7 +244,11 @@ class Sema;
     /// Not a narrowing conversion.
     NK_Not_Narrowing,
 
-    /// A narrowing conversion by virtue of the source and destination types.
+    /// Not a narrowing conversion in C++23 because the source is a bit-field
+    /// whose range can fit in the target type
+    NK_BitField_Not_Narrowing,
+
+    /// A narrowing conversion by virtue of the source and target types.
     NK_Type_Narrowing,
 
     /// A narrowing conversion, because a constant expression got narrowed.
@@ -387,6 +391,7 @@ class Sema;
     NarrowingKind
     getNarrowingKind(ASTContext &Context, const Expr *Converted,
                      APValue &ConstantValue, QualType &ConstantType,
+                     unsigned &BitFieldWidth,
                      bool IgnoreFloatToIntegralConversion = false) const;
     bool isPointerConversionToBool() const;
     bool isPointerConversionToVoidPointer(ASTContext& Context) const;

clang/lib/Sema/SemaExpr.cpp

@@ -12361,15 +12361,23 @@ static bool checkThreeWayNarrowingConversion(Sema &S, QualType ToType, Expr *E,
 
   APValue PreNarrowingValue;
   QualType PreNarrowingType;
+  unsigned BitFieldWidth;
   switch (SCS.getNarrowingKind(S.Context, E, PreNarrowingValue,
-                               PreNarrowingType,
+                               PreNarrowingType, BitFieldWidth,
                                /*IgnoreFloatToIntegralConversion*/ true)) {
   case NK_Dependent_Narrowing:
     // Implicit conversion to a narrower type, but the expression is
     // value-dependent so we can't tell whether it's actually narrowing.
   case NK_Not_Narrowing:
     return false;
 
+  case NK_BitField_Not_Narrowing:
+    if (!S.getLangOpts().CPlusPlus23) {
+      return S.Diag(E->getBeginLoc(), diag::ext_bit_field_narrowing)
+             << FromType << ToType << BitFieldWidth;
+    }
+    return false;
+
   case NK_Constant_Narrowing:
     // Implicit conversion to a narrower type, and the value is not a constant
     // expression.

clang/lib/Sema/SemaInit.cpp

@@ -10509,13 +10509,27 @@ static void DiagnoseNarrowingInInitList(Sema &S,
   // C++11 [dcl.init.list]p7: Check whether this is a narrowing conversion.
   APValue ConstantValue;
   QualType ConstantType;
+  unsigned BitFieldWidth;
   switch (SCS->getNarrowingKind(S.Context, PostInit, ConstantValue,
-                                ConstantType)) {
+                                ConstantType, BitFieldWidth)) {
   case NK_Not_Narrowing:
   case NK_Dependent_Narrowing:
     // No narrowing occurred.
     return;
 
+  case NK_BitField_Not_Narrowing:
+    // A bit-field was "narrowed" to an integer type which is wider than the
+    // bit-field but the declared type of the bit-field is wider than the target
+    // type. This is not considered narrowing in C++23.
+    if (S.getLangOpts().CPlusPlus23)
+      return;
+    if (!(S.Diag(PostInit->getBeginLoc(), diag::ext_bit_field_narrowing)
+          << PreNarrowingType
+          << EntityType.getNonReferenceType().getLocalUnqualifiedType()
+          << BitFieldWidth))
+      return;
+    break;
+
   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
@@ -10592,9 +10606,10 @@ static void CheckC23ConstexprInitConversion(Sema &S, QualType FromType,
 
   APValue Value;
   QualType PreNarrowingType;
+  unsigned BitFieldWidth;
   // Reuse C++ narrowing check.
   switch (ICS.Standard.getNarrowingKind(
-      S.Context, Init, Value, PreNarrowingType,
+      S.Context, Init, Value, PreNarrowingType, BitFieldWidth,
       /*IgnoreFloatToIntegralConversion*/ false)) {
   // The value doesn't fit.
   case NK_Constant_Narrowing:
@@ -10610,6 +10625,7 @@ static void CheckC23ConstexprInitConversion(Sema &S, QualType FromType,
 
   // Since we only reuse narrowing check for C23 constexpr variables here, we're
   // not really interested in these cases.
+  case NK_BitField_Not_Narrowing:
   case NK_Dependent_Narrowing:
   case NK_Variable_Narrowing:
   case NK_Not_Narrowing:

clang/lib/Sema/SemaOverload.cpp

@@ -331,11 +331,14 @@ static const Expr *IgnoreNarrowingConversion(ASTContext &Ctx,
 ///        value of the expression prior to the narrowing conversion.
 /// \param ConstantType  If this is an NK_Constant_Narrowing conversion, the
 ///        type of the expression prior to the narrowing conversion.
+/// \param BitFieldWidth  If this is an NK_BitField_Not_Narrowing conversion,
+///        the width of the source bit-field.
 /// \param IgnoreFloatToIntegralConversion If true type-narrowing conversions
 ///        from floating point types to integral types should be ignored.
 NarrowingKind StandardConversionSequence::getNarrowingKind(
     ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
-    QualType &ConstantType, bool IgnoreFloatToIntegralConversion) const {
+    QualType &ConstantType, unsigned &BitFieldWidth,
+    bool IgnoreFloatToIntegralConversion) const {
   assert((Ctx.getLangOpts().CPlusPlus || Ctx.getLangOpts().C23) &&
          "narrowing check outside C++");
 
@@ -463,7 +466,12 @@ NarrowingKind StandardConversionSequence::getNarrowingKind(
 
   // -- 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
+  //    (C++23) -- the source is a bit-field whose width w is less than that of
+  //    its type (or, for an enumeration type, its underlying type) and the
+  //    target type can represent all the values of a hypothetical extended
+  //    integer type with width w and with the same signedness as the original
+  //    type or
+  //    -- 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.
   case ICK_Integral_Conversion:
@@ -475,49 +483,70 @@ NarrowingKind StandardConversionSequence::getNarrowingKind(
     const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
     const unsigned ToWidth = Ctx.getIntWidth(ToType);
 
-    if (FromWidth > ToWidth ||
-        (FromWidth == ToWidth && FromSigned != ToSigned) ||
-        (FromSigned && !ToSigned)) {
-      // Not all values of FromType can be represented in ToType.
-      const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
-
-      // If it's value-dependent, we can't tell whether it's narrowing.
-      if (Initializer->isValueDependent())
-        return NK_Dependent_Narrowing;
+    constexpr auto CanRepresentAll = [](bool FromSigned, unsigned FromWidth,
+                                        bool ToSigned, unsigned ToWidth) {
+      return (FromWidth < ToWidth + (FromSigned == ToSigned)) &&
+             (FromSigned <= ToSigned);
+    };
 
-      std::optional<llvm::APSInt> OptInitializerValue;
-      if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
-        // Such conversions on variables are always narrowing.
-        return NK_Variable_Narrowing;
-      }
-      llvm::APSInt &InitializerValue = *OptInitializerValue;
-      bool Narrowing = false;
-      if (FromWidth < ToWidth) {
-        // Negative -> unsigned is narrowing. Otherwise, more bits is never
-        // narrowing.
-        if (InitializerValue.isSigned() && InitializerValue.isNegative())
-          Narrowing = true;
-      } else {
-        // Add a bit to the InitializerValue so we don't have to worry about
-        // signed vs. unsigned comparisons.
-        InitializerValue = InitializerValue.extend(
-          InitializerValue.getBitWidth() + 1);
-        // Convert the initializer to and from the target width and signed-ness.
-        llvm::APSInt ConvertedValue = InitializerValue;
-        ConvertedValue = ConvertedValue.trunc(ToWidth);
-        ConvertedValue.setIsSigned(ToSigned);
-        ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
-        ConvertedValue.setIsSigned(InitializerValue.isSigned());
-        // If the result is different, this was a narrowing conversion.
-        if (ConvertedValue != InitializerValue)
-          Narrowing = true;
-      }
-      if (Narrowing) {
-        ConstantType = Initializer->getType();
-        ConstantValue = APValue(InitializerValue);
-        return NK_Constant_Narrowing;
+    if (CanRepresentAll(FromSigned, FromWidth, ToSigned, ToWidth))
+      return NK_Not_Narrowing;
+
+    // Not all values of FromType can be represented in ToType.
+    const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
+
+    // If it's value-dependent, we can't tell whether it's narrowing.
+    if (Initializer->isValueDependent())
+      return NK_Dependent_Narrowing;
+
+    std::optional<llvm::APSInt> OptInitializerValue;
+    if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
+      // Check for bit-field whose width means that this would not be narrowing
+      // (This check is after checking for constant expressions because
+      // a constant expression that fits is never narrowing but a non-constant
+      // expression that comes from a bit-field is only not narrowing before
+      // C++23 as an extension)
+      if (const FieldDecl *BitField = Initializer->getSourceBitField()) {
+        if (BitField->getBitWidth()->isValueDependent()) {
+          return NK_Dependent_Narrowing;
+        }
+        BitFieldWidth = BitField->getBitWidthValue(Ctx);
+        if (CanRepresentAll(FromSigned, BitFieldWidth, ToSigned, ToWidth)) {
+          return NK_BitField_Not_Narrowing;
+        }
       }
+
+      // Otherwise, such a conversion is always narrowing
+      return NK_Variable_Narrowing;
+    }
+    llvm::APSInt &InitializerValue = *OptInitializerValue;
+    bool Narrowing = false;
+    if (FromWidth < ToWidth) {
+      // Negative -> unsigned is narrowing. Otherwise, more bits is never
+      // narrowing.
+      if (InitializerValue.isSigned() && InitializerValue.isNegative())
+        Narrowing = true;
+    } else {
+      // Add a bit to the InitializerValue so we don't have to worry about
+      // signed vs. unsigned comparisons.
+      InitializerValue =
+          InitializerValue.extend(InitializerValue.getBitWidth() + 1);
+      // Convert the initializer to and from the target width and signed-ness.
+      llvm::APSInt ConvertedValue = InitializerValue;
+      ConvertedValue = ConvertedValue.trunc(ToWidth);
+      ConvertedValue.setIsSigned(ToSigned);
+      ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
+      ConvertedValue.setIsSigned(InitializerValue.isSigned());
+      // If the result is different, this was a narrowing conversion.
+      if (ConvertedValue != InitializerValue)
+        Narrowing = true;
+    }
+    if (Narrowing) {
+      ConstantType = Initializer->getType();
+      ConstantValue = APValue(InitializerValue);
+      return NK_Constant_Narrowing;
     }
+
     return NK_Not_Narrowing;
   }
   case ICK_Complex_Real:
@@ -6232,14 +6261,18 @@ static ExprResult BuildConvertedConstantExpression(Sema &S, Expr *From,
   // Check for a narrowing implicit conversion.
   bool ReturnPreNarrowingValue = false;
   QualType PreNarrowingType;
+  unsigned BitFieldWidth;
   switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
-                                PreNarrowingType)) {
+                                PreNarrowingType, BitFieldWidth)) {
   case NK_Dependent_Narrowing:
     // Implicit conversion to a narrower type, but the expression is
     // value-dependent so we can't tell whether it's actually narrowing.
   case NK_Variable_Narrowing:
     // Implicit conversion to a narrower type, and the value is not a constant
     // expression. We'll diagnose this in a moment.
+  case NK_BitField_Not_Narrowing:
+    // Implicit conversion where the source is a bit-field and not a constant
+    // expression.
   case NK_Not_Narrowing:
     break;
 

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

@@ -203,6 +203,30 @@ void shrink_int() {
   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}}
+
+#if __BITINT_MAXWIDTH__ >= 3
+  _BitInt(2) S2 = 0;
+  unsigned _BitInt(2) U2 = 0;
+  _BitInt(3) S3 = 0;
+  unsigned _BitInt(3) U3 = 0;
+
+           _BitInt(2) bi0 = { S2 };
+           _BitInt(2) bi1 = { U2 }; // expected-error {{cannot be narrowed from type 'unsigned _BitInt(2)'}}
+           _BitInt(2) bi2 = { S3 }; // expected-error {{cannot be narrowed from type '_BitInt(3)'}}
+           _BitInt(2) bi3 = { U3 }; // expected-error {{cannot be narrowed from type 'unsigned _BitInt(3)'}}
+  unsigned _BitInt(2) bi4 = { S2 }; // expected-error {{cannot be narrowed from type '_BitInt(2)'}}
+  unsigned _BitInt(2) bi5 = { U2 };
+  unsigned _BitInt(2) bi6 = { S3 }; // expected-error {{cannot be narrowed from type '_BitInt(3)'}}
+  unsigned _BitInt(2) bi7 = { U3 }; // expected-error {{cannot be narrowed from type 'unsigned _BitInt(3)'}}
+           _BitInt(3) bi8 = { S2 };
+           _BitInt(3) bi9 = { U2 };
+           _BitInt(3) bia = { S3 };
+           _BitInt(3) bib = { U3 }; // expected-error {{cannot be narrowed from type 'unsigned _BitInt(3)'}}
+  unsigned _BitInt(3) bic = { S2 }; // expected-error {{cannot be narrowed from type '_BitInt(2)'}}
+  unsigned _BitInt(3) bid = { U2 };
+  unsigned _BitInt(3) bie = { S3 }; // expected-error {{cannot be narrowed from type '_BitInt(3)'}}
+  unsigned _BitInt(3) bif = { U3 };
+#endif
 }
 
 // Be sure that type- and value-dependent expressions in templates get the error