Allow implicit conversion for class/struct types with conversion operators. Explicit conversion must be done for all other types.

Author: chaitanyav

clang/docs/ReleaseNotes.rst

@@ -328,7 +328,8 @@ Non-comprehensive list of changes in this release
 - Added ``__builtin_stdc_rotate_left`` and ``__builtin_stdc_rotate_right``
   for bit rotation of unsigned integers including ``_BitInt`` types. Rotation
   counts are normalized modulo the bit-width and support negative values.
-  Usable in constant expressions.
+  Usable in constant expressions. Implicit conversion is supported for
+  class/struct types with conversion operators.
 
 New Compiler Flags
 ------------------

clang/lib/Sema/SemaChecking.cpp

@@ -2322,62 +2322,100 @@ static bool BuiltinCountZeroBitsGeneric(Sema &S, CallExpr *TheCall) {
   return false;
 }
 
+class RotateIntegerConverter : public Sema::ContextualImplicitConverter {
+  unsigned ArgIndex;
+  bool OnlyUnsigned;
+
+  Sema::SemaDiagnosticBuilder emitError(Sema &S, SourceLocation Loc,
+                                        QualType T) {
+    return S.Diag(Loc, diag::err_builtin_invalid_arg_type)
+           << ArgIndex << /*scalar*/ 1
+           << (OnlyUnsigned ? /*unsigned integer*/ 3 : /*integer*/ 1)
+           << /*no fp*/ 0 << T;
+  }
+
+public:
+  RotateIntegerConverter(unsigned ArgIndex, bool OnlyUnsigned)
+      : ContextualImplicitConverter(/*Suppress=*/false,
+                                    /*SuppressConversion=*/true),
+        ArgIndex(ArgIndex), OnlyUnsigned(OnlyUnsigned) {}
+
+  bool match(QualType T) override {
+    return OnlyUnsigned ? T->isUnsignedIntegerType() : T->isIntegerType();
+  }
+
+  Sema::SemaDiagnosticBuilder diagnoseNoMatch(Sema &S, SourceLocation Loc,
+                                              QualType T) override {
+    return emitError(S, Loc, T);
+  }
+
+  Sema::SemaDiagnosticBuilder diagnoseIncomplete(Sema &S, SourceLocation Loc,
+                                                 QualType T) override {
+    return emitError(S, Loc, T);
+  }
+
+  Sema::SemaDiagnosticBuilder diagnoseExplicitConv(Sema &S, SourceLocation Loc,
+                                                   QualType T,
+                                                   QualType ConvTy) override {
+    return emitError(S, Loc, T);
+  }
+
+  Sema::SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv,
+                                               QualType ConvTy) override {
+    return S.Diag(Conv->getLocation(), diag::note_conv_function_declared_at);
+  }
+
+  Sema::SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc,
+                                                QualType T) override {
+    return emitError(S, Loc, T);
+  }
+
+  Sema::SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv,
+                                            QualType ConvTy) override {
+    return S.Diag(Conv->getLocation(), diag::note_conv_function_declared_at);
+  }
+
+  Sema::SemaDiagnosticBuilder diagnoseConversion(Sema &S, SourceLocation Loc,
+                                                 QualType T,
+                                                 QualType ConvTy) override {
+    llvm_unreachable("conversion functions are permitted");
+  }
+};
+
 /// Checks that __builtin_stdc_rotate_{left,right} was called with two
 /// arguments, that the first argument is an unsigned integer type, and that
 /// the second argument is an integer type.
 static bool BuiltinRotateGeneric(Sema &S, CallExpr *TheCall) {
   if (S.checkArgCount(TheCall, 2))
     return true;
 
-  ExprResult Arg0Res = S.DefaultLvalueConversion(TheCall->getArg(0));
+  // First argument (value to rotate) must be unsigned integer type.
+  RotateIntegerConverter Arg0Converter(1, /*OnlyUnsigned=*/true);
+  ExprResult Arg0Res = S.PerformContextualImplicitConversion(
+      TheCall->getArg(0)->getBeginLoc(), TheCall->getArg(0), Arg0Converter);
   if (Arg0Res.isInvalid())
     return true;
 
   Expr *Arg0 = Arg0Res.get();
   TheCall->setArg(0, Arg0);
 
   QualType Arg0Ty = Arg0->getType();
-  if (!Arg0Ty->isUnsignedIntegerType()) {
-    ExprResult ConvArg0Res = S.PerformImplicitConversion(
-        TheCall->getArg(0), S.Context.UnsignedIntTy, AssignmentAction::Passing);
-    if (ConvArg0Res.isUsable()) {
-      Arg0 = ConvArg0Res.get();
-      Arg0Ty = Arg0->getType();
-      TheCall->setArg(0, Arg0);
-    }
-  }
-
-  if (!Arg0Ty->isUnsignedIntegerType()) {
-    S.Diag(Arg0->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 1 << /* scalar */ 1 << /* unsigned integer ty */ 3 << /* no fp */ 0
-        << Arg0Ty;
+  if (!Arg0Ty->isUnsignedIntegerType())
     return true;
-  }
 
-  ExprResult Arg1Res = S.DefaultLvalueConversion(TheCall->getArg(1));
+  // Second argument (rotation count) must be integer type.
+  RotateIntegerConverter Arg1Converter(2, /*OnlyUnsigned=*/false);
+  ExprResult Arg1Res = S.PerformContextualImplicitConversion(
+      TheCall->getArg(1)->getBeginLoc(), TheCall->getArg(1), Arg1Converter);
   if (Arg1Res.isInvalid())
     return true;
 
   Expr *Arg1 = Arg1Res.get();
   TheCall->setArg(1, Arg1);
 
   QualType Arg1Ty = Arg1->getType();
-
-  if (!Arg1Ty->isIntegerType()) {
-    ExprResult ConvArg1Res = S.PerformImplicitConversion(
-        TheCall->getArg(1), S.Context.IntTy, AssignmentAction::Passing);
-    if (ConvArg1Res.isUsable()) {
-      Arg1 = ConvArg1Res.get();
-      Arg1Ty = Arg1->getType();
-      TheCall->setArg(1, Arg1);
-    }
-  }
-
-  if (!Arg1Ty->isIntegerType()) {
-    S.Diag(Arg1->getBeginLoc(), diag::err_builtin_invalid_arg_type)
-        << 2 << /* scalar */ 1 << /* integer ty */ 2 << /* no fp */ 0 << Arg1Ty;
+  if (!Arg1Ty->isIntegerType())
     return true;
-  }
 
   TheCall->setType(Arg0Ty);
   return false;

clang/test/Sema/builtin-stdc-rotate.c

@@ -105,22 +105,28 @@ void test_errors(int si, float f) {
   __builtin_stdc_rotate_left(ui, 1, 2); // expected-error {{too many arguments to function call}}
 }
 
-void test_implicit_conversions(_Bool b, float f, int si) {
+void test_valid_conversions(_Bool b, int si) {
   unsigned int ui = 5;
 
-  // Test implicit conversions for second argument
+  // Valid: bool converts to int for second argument
   (void)__builtin_stdc_rotate_left(ui, b);
-  (void)__builtin_stdc_rotate_left(ui, f);
-  (void)__builtin_stdc_rotate_left(ui, 1.5); // expected-warning {{implicit conversion from 'double' to 'int' changes value from 1.5 to 1}}
   (void)__builtin_stdc_rotate_right(ui, b);
-  (void)__builtin_stdc_rotate_right(ui, f);
 
-  // Test implicit conversions for first argument
-  (void)__builtin_stdc_rotate_left(si, 1);
-  (void)__builtin_stdc_rotate_left(-5, 1);
-  (void)__builtin_stdc_rotate_right(3.0, 1.5); // expected-warning {{implicit conversion from 'double' to 'int' changes value from 1.5 to 1}}
+  // Valid: signed int is an integer type for second argument
+  (void)__builtin_stdc_rotate_left(ui, si);
+  (void)__builtin_stdc_rotate_right(ui, si);
+}
+
+void test_invalid_types(float f, int si) {
+  unsigned int ui = 5;
+
+  // Invalid: float is not an integer type for second argument
+  (void)__builtin_stdc_rotate_left(ui, f); // expected-error {{2nd argument must be a scalar integer type (was 'float')}}
+  (void)__builtin_stdc_rotate_left(ui, 1.5); // expected-error {{2nd argument must be a scalar integer type (was 'double')}}
+  (void)__builtin_stdc_rotate_right(ui, f); // expected-error {{2nd argument must be a scalar integer type (was 'float')}}
 
-  // Test narrowing conversion in assignment
-  unsigned _BitInt(17) rotated_odd = __builtin_stdc_rotate_left(0x1ABCD, 5); // expected-warning {{implicit conversion from 'unsigned int' to 'unsigned _BitInt(17)' changes value from 3504544 to 96672}}
-  (void)rotated_odd;
+  // Invalid: signed int is not unsigned for first argument
+  (void)__builtin_stdc_rotate_left(si, 1); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}}
+  (void)__builtin_stdc_rotate_left(-5, 1); // expected-error {{1st argument must be a scalar unsigned integer type (was 'int')}}
+  (void)__builtin_stdc_rotate_right(3.0, 1); // expected-error {{1st argument must be a scalar unsigned integer type (was 'double')}}
 }

clang/test/SemaCXX/constexpr-builtin-stdc-rotate.cpp

@@ -185,15 +185,16 @@ void test_implicit_conversions() {
   auto result4 = __builtin_stdc_rotate_right(uw, RotateAmount::ROTATE_BY_4);
 
   bool b = true;
-  float f = 3.7f;
   auto result5 = __builtin_stdc_rotate_left(10U, b);
-  auto result6 = __builtin_stdc_rotate_left(10U, f);
-  auto result7 = __builtin_stdc_rotate_right(10U, 2.9f); // expected-warning {{implicit conversion from 'float' to 'int' changes value from 2.9000001 to 2}}
 }
 
-void test_no_conversions() {
+void test_invalid_types() {
+  float f = 3.7f;
+  auto result6 = __builtin_stdc_rotate_left(10U, f); // expected-error {{2nd argument must be a scalar integer type (was 'float')}}
+  auto result7 = __builtin_stdc_rotate_right(10U, 2.9f); // expected-error {{2nd argument must be a scalar integer type (was 'float')}}
+
   NoConversion nc;
-  auto result1 = __builtin_stdc_rotate_left(5U, nc); // expected-error {{passing 'NoConversion' to parameter of incompatible type 'int'}} expected-error {{2nd argument must be a scalar signed integer type (was 'NoConversion')}}
+  auto result1 = __builtin_stdc_rotate_left(5U, nc); // expected-error {{2nd argument must be a scalar integer type (was 'NoConversion')}}
 }
 
 } // namespace test_conversions