Update __is_unsigned builtin to match the Standard.

[zoecarver]

Summary

Updates __is_unsigned to have the same behavior as the standard specifies. This is in line with 511dbd8, which applied the same change to __is_signed.

Refs D67897.

[zoecarver]

clang/docs/LanguageExtensions.rst

1199

Just re-flowing the line here, which I neglected to do in the other commit.

[• Quuxplusone]

🎉

clang/lib/Sema/SemaExprCXX.cpp

4863

FWIW, I'd lose the parenthetical comment, and I'd write the conditions as respectively

return T->isUnsignedIntegerType() && !T->isEnumeralType();

return T->isFloatingType() || (T->isSignedIntegerType() && !T->isEnumeralType());

both because "T not being an enum type" is expected to be usually true, and because I think (!x && y) runs the risk of being misread as !(x && y), whereas (x && !y) is easy on the brain.

clang/test/SemaCXX/type-traits.cpp

1473

I think you should check F(__is_unsigned(SignedEnum)) here, too, just for the record.
And F(__is_signed(UnsignedEnum)) in the other place.

[zoecarver]

clang/lib/Sema/SemaExprCXX.cpp

4863

Fair enough. I originally was thinking, if we have to perform this check roughly 50% of this time, either way, it makes sense to do the much faster check first. But, if we assume that we almost never receive an enum type, then what you're saying makes sense. I'll fix it.

[zoecarver]

• Address Arthur's comments.

[• Quuxplusone]

LGTM now, mod the (important!) typo in the test.

clang/test/SemaCXX/type-traits.cpp

1444

s/is_unsigned/is_signed/

[rsmith]

clang/docs/LanguageExtensions.rst

1206–1207

Please add a trailing colon to this line to match the other lines with additional text after the parentheses.

clang/lib/Sema/SemaExprCXX.cpp

4859–4860

Please reflow this line so it fits in 80 columns.

[rsmith]

LGTM too, once the remaining pending comments are addressed.

[zoecarver]

Sorry for the delay in updating. All review comments have been addressed. Thanks!

[zoecarver]

• Fix review comments: add colon, reflow line, and fix typo.

clang/docs/LanguageExtensions.rst

 * ``__is_reference`` (C++, Embarcadero)
 * ``__is_rvalue_reference`` (C++, Embarcadero)
 * ``__is_same`` (C++, Embarcadero)
 * ``__is_same_as`` (GCC): Synonym for ``__is_same``.
 * ``__is_scalar`` (C++, Embarcadero)
 * ``__is_sealed`` (Microsoft):
   Synonym for ``__is_final``.
 * ``__is_signed`` (C++, Embarcadero):
-  Returns false for enumeration types, and returns true for floating-point types. Note, before Clang 10, returned true for enumeration types if the underlying type was signed, and returned false for floating-point types.
+  Returns false for enumeration types, and returns true for floating-point
+  types. Note, before Clang 10, returned true for enumeration types if the
+  underlying type was signed, and returned false 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)
-  Note that this currently returns true for enumeration types if the underlying
-  type is unsigned, in violation of the requirements for ``std::is_unsigned``.
-  This behavior is likely to change in a future version of Clang.
+* ``__is_unsigned`` (C++, Embarcadero):
+  Returns false for enumeration types. Note, before Clang 13, returned true for
+  enumeration types if the underlying type was unsigned.
 * ``__is_void`` (C++, Embarcadero)
 * ``__is_volatile`` (C++, Embarcadero)
 * ``__reference_binds_to_temporary(T, U)`` (Clang):  Determines whether a
   reference of type ``T`` bound to an expression of type ``U`` would bind to a
   materialized temporary object. If ``T`` is not a reference type the result
   is false. Note this trait will also return false when the initialization of
   ``T`` from ``U`` is ill-formed.
 * ``__underlying_type`` (C++, GNU, Microsoft)

clang/lib/Sema/SemaExprCXX.cpp

static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
   case UTT_IsFinal:
   case UTT_IsSealed:
     if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
       return RD->hasAttr<FinalAttr>();
     return false;
   case UTT_IsSigned:
     // Enum types should always return false.
     // Floating points should always return true.
-    return !T->isEnumeralType() && (T->isFloatingType() || T->isSignedIntegerType());
+    return T->isFloatingType() ||
+           (T->isSignedIntegerType() && !T->isEnumeralType());
   case UTT_IsUnsigned:
-    return T->isUnsignedIntegerType();
+    // Enum types should always return false.
+    return T->isUnsignedIntegerType() && !T->isEnumeralType();
 
     // 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.
     //
     //   1: http://gcc.gnu/.org/onlinedocs/gcc/Type-Traits.html

clang/test/SemaCXX/type-traits.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s
 
 #define T(b) (b) ? 1 : -1
 #define F(b) (b) ? -1 : 1
 
 struct NonPOD { NonPOD(int); };
 typedef NonPOD NonPODAr[10];
 typedef NonPOD NonPODArNB[];
 typedef NonPOD NonPODArMB[10][2];
 
 // PODs
 enum Enum { EV };
 enum SignedEnum : signed int { };
+enum UnsignedEnum : unsigned int { };
 struct POD { Enum e; int i; float f; NonPOD* p; };
 struct Empty {};
 struct IncompleteStruct;
 typedef Empty EmptyAr[10];
 typedef Empty EmptyArNB[];
 typedef Empty EmptyArMB[1][2];
 typedef int Int;
 typedef Int IntAr[10];
void is_signed()
   int t20[F(__is_signed(void))];
   int t21[F(__is_signed(ClassType))];
   int t22[F(__is_signed(Derives))];
   int t23[F(__is_signed(Enum))];
   int t24[F(__is_signed(SignedEnum))];
   int t25[F(__is_signed(IntArNB))];
   int t26[F(__is_signed(Union))];
   int t27[F(__is_signed(UnionAr))];
+  int t28[F(__is_signed(UnsignedEnum))];
 }
 
 void is_unsigned()
 {
   int t01[T(__is_unsigned(bool))];
   int t02[T(__is_unsigned(unsigned char))];
   int t03[T(__is_unsigned(unsigned short))];
   int t04[T(__is_unsigned(unsigned int))];
   int t05[T(__is_unsigned(unsigned long))];
   int t06[T(__is_unsigned(unsigned long long))];
-  int t07[T(__is_unsigned(Enum))];
 
   int t10[F(__is_unsigned(void))];
   int t11[F(__is_unsigned(cvoid))];
   int t12[F(__is_unsigned(float))];
   int t13[F(__is_unsigned(double))];
   int t14[F(__is_unsigned(long double))];
   int t16[F(__is_unsigned(char))];
   int t17[F(__is_unsigned(signed char))];
   int t18[F(__is_unsigned(wchar_t))];
   int t19[F(__is_unsigned(short))];
   int t20[F(__is_unsigned(int))];
   int t21[F(__is_unsigned(long))];
   int t22[F(__is_unsigned(Union))];
   int t23[F(__is_unsigned(UnionAr))];
   int t24[F(__is_unsigned(Derives))];
   int t25[F(__is_unsigned(ClassType))];
   int t26[F(__is_unsigned(IntArNB))];
+  int t27[F(__is_unsigned(Enum))];
+  int t28[F(__is_unsigned(UnsignedEnum))];
+  int t29[F(__is_unsigned(SignedEnum))];
 }
 
 typedef Int& IntRef;
 typedef const IntAr ConstIntAr;
 typedef ConstIntAr ConstIntArAr[4];
 
 struct HasCopy {
   HasCopy(HasCopy& cp);