Fix __is_signed builtin

[zoecarver]

Summary

This patch fixes the __is_signed builtin type trait to work with floating point types. Now, the builtin will return true if it is passed a floating point type.

[• Quuxplusone]

But std::is_signed_v<float> needs to yield false. Isn't it cleaner to leave the compiler builtin matching the library type-trait, so that the library doesn't have to check for integral types separately?

[rsmith]

Looks good, but please also update http://clang.llvm.org/docs/LanguageExtensions.html#type-trait-primitives

(Can I interest you in fixing the misbehaviour for enumeration types too?)

[zoecarver]

In D67897#1678388, @Quuxplusone wrote:

But std::is_signed_v<float> needs to yield false. Isn't it cleaner to leave the compiler builtin matching the library type-trait, so that the library doesn't have to check for integral types separately?

The idea is that these will match the standard. I don't see anywhere where the standard says that floating-point types yield false. The currently libc++ implementation also yields true for your example.

[rsmith]

In D67897#1678388, @Quuxplusone wrote:

But std::is_signed_v<float> needs to yield false.

It should yield true; the spec says "If is_­arithmetic_­v<T> is true, the same result as T(-1) < T(0); otherwise, false".

[• Quuxplusone]

In D67897#1678392, @rsmith wrote:

In D67897#1678388, @Quuxplusone wrote:

But std::is_signed_v<float> needs to yield false.

It should yield true; the spec says "If is_­arithmetic_­v<T> is true, the same result as T(-1) < T(0); otherwise, false".

Whoops! Never mind me.

[zoecarver]

(Can I interest you in fixing the misbehaviour for enumeration types too?)

Certainly. You mean that __is_signed should return false for enumeration types?

[zoecarver]

• fix docs

[rsmith]

In D67897#1678420, @zoecarver wrote:

(Can I interest you in fixing the misbehaviour for enumeration types too?)

Certainly. You mean that __is_signed should return false for enumeration types?

Yes, exactly.

clang/docs/LanguageExtensions.rst

1165

I'd just drop the second half of this sentence, and keep the "likely to change" warning for the non-conformance for enumeration types until that's fixed. (We already have an introductory sentence that says we follow the standard-specified behavior for traits marked (C++) unless otherwise specified.)

[zoecarver]

• fix behavior when passed an enumeration type

[rsmith]

Thanks!

clang/docs/LanguageExtensions.rst

1165

Now that this does the standard thing, you can delete this text entirely, or add a "before Clang 10, returned true for enumeration types if the underlying type was signed, and returned false for floating-point types".

[zoecarver]

clang/docs/LanguageExtensions.rst

1165

I'll add that text before committing.

[zoecarver]

Resolved by rL372621.

clang/docs/LanguageExtensions.rst

 * ``__is_reference`` (C++, Embarcadero)
 * ``__is_rvalue_reference`` (C++, Embarcadero)
 * ``__is_same`` (C++, Embarcadero)
 * ``__is_scalar`` (C++, Embarcadero)
 * ``__is_sealed`` (Microsoft):
   Synonym for ``__is_final``.
 * ``__is_signed`` (C++, Embarcadero):
   Note that this currently returns true for enumeration types if the underlying
-  type is signed, and returns false for floating-point types, in violation of
-  the requirements for ``std::is_signed``. This behavior is likely to change in
-  a future version of Clang.
+  type is signed, and returns true for floating-point types.
 * ``__is_standard_layout`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_trivial`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_trivially_assignable`` (C++, GNU, Microsoft)
 * ``__is_trivially_constructible`` (C++, GNU, Microsoft)
 * ``__is_trivially_copyable`` (C++, GNU, Microsoft)
 * ``__is_trivially_destructible`` (C++, MSVC 2013)
 * ``__is_union`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_unsigned`` (C++, Embarcadero)

clang/lib/Sema/SemaExprCXX.cpp

static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
   case UTT_IsInterfaceClass:
     return false;
   case UTT_IsFinal:
   case UTT_IsSealed:
     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
       return RD->hasAttr<FinalAttr>();
     return false;
   case UTT_IsSigned:
-    return T->isSignedIntegerType();
+    return T->isFloatingType() || T->isSignedIntegerType();
   case UTT_IsUnsigned:
     return T->isUnsignedIntegerType();
 
     // Type trait expressions which query classes regarding their construction,
     // destruction, and copying. Rather than being based directly on the
     // related type predicates in the standard, they are specified by both
     // GCC[1] and the Embarcadero C++ compiler[2], and Clang implements those
     // specifications.

clang/test/SemaCXX/type-traits.cpp

 struct DerivesEmpty : Empty {};
 struct HasCons { HasCons(int); };
 struct HasDefaultCons { HasDefaultCons() = default; };
 struct HasExplicitDefaultCons { explicit HasExplicitDefaultCons() = default; };
 struct HasInheritedCons : HasDefaultCons { using HasDefaultCons::HasDefaultCons; };
 struct HasNoInheritedCons : HasCons {};
 struct HasCopyAssign { HasCopyAssign operator =(const HasCopyAssign&); };
 struct HasMoveAssign { HasMoveAssign operator =(const HasMoveAssign&&); };
-struct HasNoThrowMoveAssign { 
+struct HasNoThrowMoveAssign {
   HasNoThrowMoveAssign& operator=(
     const HasNoThrowMoveAssign&&) throw(); };
-struct HasNoExceptNoThrowMoveAssign { 
+struct HasNoExceptNoThrowMoveAssign {
   HasNoExceptNoThrowMoveAssign& operator=(
-    const HasNoExceptNoThrowMoveAssign&&) noexcept; 
+    const HasNoExceptNoThrowMoveAssign&&) noexcept;
 };
-struct HasThrowMoveAssign { 
+struct HasThrowMoveAssign {
   HasThrowMoveAssign& operator=(const HasThrowMoveAssign&&)
 #if __cplusplus <= 201402L
   throw(POD);
 #else
   noexcept(false);
 #endif
 };
 
 
-struct HasNoExceptFalseMoveAssign { 
+struct HasNoExceptFalseMoveAssign {
   HasNoExceptFalseMoveAssign& operator=(
     const HasNoExceptFalseMoveAssign&&) noexcept(false); };
 struct HasMoveCtor { HasMoveCtor(const HasMoveCtor&&); };
 struct HasMemberMoveCtor { HasMoveCtor member; };
 struct HasMemberMoveAssign { HasMoveAssign member; };
 struct HasStaticMemberMoveCtor { static HasMoveCtor member; };
 struct HasStaticMemberMoveAssign { static HasMoveAssign member; };
 struct HasMemberThrowMoveAssign { HasThrowMoveAssign member; };
-struct HasMemberNoExceptFalseMoveAssign { 
+struct HasMemberNoExceptFalseMoveAssign {
   HasNoExceptFalseMoveAssign member; };
 struct HasMemberNoThrowMoveAssign { HasNoThrowMoveAssign member; };
-struct HasMemberNoExceptNoThrowMoveAssign { 
+struct HasMemberNoExceptNoThrowMoveAssign {
   HasNoExceptNoThrowMoveAssign member; };
 
-struct HasDefaultTrivialCopyAssign { 
+struct HasDefaultTrivialCopyAssign {
   HasDefaultTrivialCopyAssign &operator=(
-    const HasDefaultTrivialCopyAssign&) = default; 
+    const HasDefaultTrivialCopyAssign&) = default;
 };
-struct TrivialMoveButNotCopy { 
+struct TrivialMoveButNotCopy {
   TrivialMoveButNotCopy &operator=(TrivialMoveButNotCopy&&) = default;
   TrivialMoveButNotCopy &operator=(const TrivialMoveButNotCopy&);
 };
 struct NonTrivialDefault {
   NonTrivialDefault();
 };
 
 struct HasDest { ~HasDest(); };
void is_enum()
   { int arr[F(__is_enum(cvoid))]; }
   { int arr[F(__is_enum(IntArNB))]; }
   { int arr[F(__is_enum(HasAnonymousUnion))]; }
 }
 
 struct FinalClass final {
 };
 
-template<typename T> 
+template<typename T>
 struct PotentiallyFinal { };
 
 template<typename T>
 struct PotentiallyFinal<T*> final { };
 
 template<>
 struct PotentiallyFinal<int> final { };
 

 void is_signed()
 {
   //int t01[T(__is_signed(char))];
   int t02[T(__is_signed(int))];
   int t03[T(__is_signed(long))];
   int t04[T(__is_signed(short))];
   int t05[T(__is_signed(signed char))];
   int t06[T(__is_signed(wchar_t))];
+  int t07[T(__is_signed(float))];
+  int t08[T(__is_signed(double))];
+  int t09[T(__is_signed(long double))];
 
-  int t10[F(__is_signed(bool))];
-  int t11[F(__is_signed(cvoid))];
-  int t12[F(__is_signed(float))];
-  int t13[F(__is_signed(double))];
-  int t14[F(__is_signed(long double))];
+  int t13[F(__is_signed(bool))];
+  int t14[F(__is_signed(cvoid))];
   int t15[F(__is_signed(unsigned char))];
   int t16[F(__is_signed(unsigned int))];
   int t17[F(__is_signed(unsigned long long))];
   int t18[F(__is_signed(unsigned long))];
   int t19[F(__is_signed(unsigned short))];
   int t20[F(__is_signed(void))];
   int t21[F(__is_signed(ClassType))];
   int t22[F(__is_signed(Derives))];

 
 void is_convertible_to();
 class PrivateCopy {
   PrivateCopy(const PrivateCopy&);
   friend void is_convertible_to();
 };
 
 template<typename T>
-struct X0 { 
+struct X0 {
   template<typename U> X0(const X0<U>&);
 };
 
 struct Abstract { virtual void f() = 0; };
 
 void is_convertible_to() {
   { int arr[T(__is_convertible_to(Int, Int))]; }
   { int arr[F(__is_convertible_to(Int, IntAr))]; }

 struct NotUniqueBecauseTailPadding {
   int &r;
   char a;
 };
 struct CanBeUniqueIfNoPadding : NotUniqueBecauseTailPadding {
   char b[7];
 };
 
-static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value, 
+static_assert(!has_unique_object_representations<NotUniqueBecauseTailPadding>::value,
               "non trivial");
 // Can be unique on Itanium, since the is child class' data is 'folded' into the
 // parent's tail padding.
 static_assert(sizeof(CanBeUniqueIfNoPadding) != 16 ||
               has_unique_object_representations<CanBeUniqueIfNoPadding>::value,
               "inherit from std layout");
 
 namespace ErrorType {
   struct S; //expected-note{{forward declaration of 'ErrorType::S'}}
 
   struct T {
         S t; //expected-error{{field has incomplete type 'ErrorType::S'}}
   };
   bool b = __has_unique_object_representations(T);
 };