[clang] adds `__is_scoped_enum`, `__is_nullptr`, and `__is_referenceable`

[cjdb]

Summary

... as builtins.

This is information that the compiler already has, and should be exposed
so that the library doesn't need to reimplement the exact same
functionality.

This was originally a part of D116280.

Depends on D135175.

[cjdb]

Replaces T/F with static_assert to match D116203

[cjdb]

Updates the commit message so patch applications work

[erichkeane]

LGTM... Please do the re-ordering separately here, unless it was necessary here.

clang/lib/Parse/ParseExpr.cpp

1071

Can you just put this in the right place in the other commit?

1079

Why are the rest of these re-ordered? Feel free to do an NFC re-ordering these, but please dont do them here.

[aaron.ballman]

clang/test/SemaCXX/type-traits.cpp

405

It'd probably not be a bad idea at some point to add test coverage for incomplete types.

830

I think we should have test cases for the following:

struct incomplete;

__is_referenceable(struct incomplete); // Also interesting to make sure we handle elaborated type specifiers properly

typedef void function_type(int);
__is_referenceable(function_type); // Note, this is not a function *pointer* type

struct S {
  void func1() &;
  void func2() const;
};

// Both of these should be false, by my understanding of what "referenceable" means in the standard.
__is_referenceable(decltype(&S::func1));
__is_referenceable(decltype(&S::func2));

[aaron.ballman]

Assuming the additional test cases don't uncover any surprises, this LGTM as well (modulo nits already brought up).

[Mordante]

clang/include/clang/Basic/TokenKinds.def

525

Shouldn't these traits be documented or is the documentation generated automatically from the def files?

[cjdb]

applies feedback, rebases, adds documentation

[aaron.ballman]

clang/test/SemaCXX/type-traits.cpp

830

Do you have a test for:

struct S {
  void func1() &;
  void func2() const;
};

// Both of these should be false, by my understanding of what "referenceable" means in the standard.
__is_referenceable(decltype(&S::func1));
__is_referenceable(decltype(&S::func2));

[cjdb]

clang/lib/Parse/ParseExpr.cpp

1071

Yeah, this feels like a commit split issue. Thanks for catching.

clang/test/SemaCXX/type-traits.cpp

405

I've added that coverage for __is_enum above too.

830

I think the latter two are pointer-to-member functions, which are referenceable. We want to check void(int) const, which is done on the last green line of this file.

[aaron.ballman]

LGTM

clang/test/SemaCXX/type-traits.cpp

830

Ah thank you for showing me we already had the coverage!

clang/docs/LanguageExtensions.rst

 * ``__is_lvalue_reference`` (C++, Embarcadero)
 * ``__is_member_object_pointer`` (C++, Embarcadero)
 * ``__is_member_function_pointer`` (C++, Embarcadero)
 * ``__is_member_pointer`` (C++, Embarcadero)
 * ``__is_nothrow_assignable`` (C++, MSVC 2013)
 * ``__is_nothrow_constructible`` (C++, MSVC 2013)
 * ``__is_nothrow_destructible`` (C++, MSVC 2013)
   Only available in ``-fms-extensions`` mode.
+* ``__is_nullptr`` (C++, GNU, Microsoft, Embarcadero):
+  Returns true for ``std::nullptr_t`` and false for everything else. The
+  corresponding standard library feature is ``std::is_null_pointer``, but
+  ``__is_null_pointer`` is already in use by some implementations.
 * ``__is_object`` (C++, Embarcadero)
 * ``__is_pod`` (C++, GNU, Microsoft, Embarcadero):
   Note, the corresponding standard trait was deprecated in C++20.
 * ``__is_pointer`` (C++, Embarcadero)
 * ``__is_polymorphic`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_reference`` (C++, Embarcadero)
+* ``__is_referenceable`` (C++, GNU, Microsoft, Embarcadero):
+  Returns true if a type is referenceable, and false otherwise. A referenceable
+  type is a type that's either an object type, a reference type, or an unqualified
+  function type.
 * ``__is_rvalue_reference`` (C++, Embarcadero)
 * ``__is_same`` (C++, Embarcadero)
 * ``__is_same_as`` (GCC): Synonym for ``__is_same``.
 * ``__is_scalar`` (C++, Embarcadero)
+* ``__is_scoped_enum`` (C++, GNU, Microsoft, 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.
 * ``__is_standard_layout`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_trivial`` (C++, GNU, Microsoft, Embarcadero)

clang/include/clang/Basic/TokenKinds.def

 
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) KEYWORD(__##Trait, KEYCXX)
 #include "clang/Basic/TransformTypeTraits.def"
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
+TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
+TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
+TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)

clang/lib/Parse/ParseDeclCXX.cpp

#include "clang/Basic/TransformTypeTraits.def"
           tok::kw___is_lvalue_expr,
           tok::kw___is_lvalue_reference,
           tok::kw___is_member_function_pointer,
           tok::kw___is_member_object_pointer,
           tok::kw___is_member_pointer,
           tok::kw___is_nothrow_assignable,
           tok::kw___is_nothrow_constructible,
           tok::kw___is_nothrow_destructible,
+          tok::kw___is_nullptr,
           tok::kw___is_object,
           tok::kw___is_pod,
           tok::kw___is_pointer,
           tok::kw___is_polymorphic,
           tok::kw___is_reference,
+          tok::kw___is_referenceable,
           tok::kw___is_rvalue_expr,
           tok::kw___is_rvalue_reference,
           tok::kw___is_same,
           tok::kw___is_scalar,
+          tok::kw___is_scoped_enum,
           tok::kw___is_sealed,
           tok::kw___is_signed,
           tok::kw___is_standard_layout,
           tok::kw___is_trivial,
           tok::kw___is_trivially_assignable,
           tok::kw___is_trivially_constructible,
           tok::kw___is_trivially_copyable,
           tok::kw___is_unbounded_array,

clang/lib/Parse/ParseExpr.cpp

#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
             = RTT_JOIN(tok::kw_,Name)
 
           REVERTIBLE_TYPE_TRAIT(__is_abstract);
           REVERTIBLE_TYPE_TRAIT(__is_aggregate);
           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
           REVERTIBLE_TYPE_TRAIT(__is_array);
           REVERTIBLE_TYPE_TRAIT(__is_assignable);
-          REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
+          REVERTIBLE_TYPE_TRAIT(__is_bounded_array);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);
           REVERTIBLE_TYPE_TRAIT(__is_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible);
           REVERTIBLE_TYPE_TRAIT(__is_convertible_to);
           REVERTIBLE_TYPE_TRAIT(__is_destructible);
           REVERTIBLE_TYPE_TRAIT(__is_empty);
           REVERTIBLE_TYPE_TRAIT(__is_enum);
           REVERTIBLE_TYPE_TRAIT(__is_floating_point);
           REVERTIBLE_TYPE_TRAIT(__is_final);
           REVERTIBLE_TYPE_TRAIT(__is_function);
           REVERTIBLE_TYPE_TRAIT(__is_fundamental);
           REVERTIBLE_TYPE_TRAIT(__is_integral);
           REVERTIBLE_TYPE_TRAIT(__is_interface_class);
           REVERTIBLE_TYPE_TRAIT(__is_literal);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_expr);
           REVERTIBLE_TYPE_TRAIT(__is_lvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_member_function_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_object_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_member_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_nothrow_destructible);
+          REVERTIBLE_TYPE_TRAIT(__is_nullptr);
           REVERTIBLE_TYPE_TRAIT(__is_object);
           REVERTIBLE_TYPE_TRAIT(__is_pod);
           REVERTIBLE_TYPE_TRAIT(__is_pointer);
           REVERTIBLE_TYPE_TRAIT(__is_polymorphic);
           REVERTIBLE_TYPE_TRAIT(__is_reference);
+          REVERTIBLE_TYPE_TRAIT(__is_referenceable);
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_expr);
           REVERTIBLE_TYPE_TRAIT(__is_rvalue_reference);
           REVERTIBLE_TYPE_TRAIT(__is_same);
           REVERTIBLE_TYPE_TRAIT(__is_scalar);
+          REVERTIBLE_TYPE_TRAIT(__is_scoped_enum);
           REVERTIBLE_TYPE_TRAIT(__is_sealed);
           REVERTIBLE_TYPE_TRAIT(__is_signed);
           REVERTIBLE_TYPE_TRAIT(__is_standard_layout);
           REVERTIBLE_TYPE_TRAIT(__is_trivial);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
           REVERTIBLE_TYPE_TRAIT(__is_unbounded_array);

clang/lib/Sema/SemaExprCXX.cpp

case UTT_IsCompleteType:
     // requiring a complete type, as whether or not they return true cannot be
     // impacted by the completeness of the type.
   case UTT_IsVoid:
   case UTT_IsIntegral:
   case UTT_IsFloatingPoint:
   case UTT_IsArray:
   case UTT_IsBoundedArray:
   case UTT_IsPointer:
+  case UTT_IsNullPointer:
+  case UTT_IsReferenceable:
   case UTT_IsLvalueReference:
   case UTT_IsRvalueReference:
   case UTT_IsMemberFunctionPointer:
   case UTT_IsMemberObjectPointer:
   case UTT_IsEnum:
+  case UTT_IsScopedEnum:
   case UTT_IsUnion:
   case UTT_IsClass:
   case UTT_IsFunction:
   case UTT_IsReference:
   case UTT_IsArithmetic:
   case UTT_IsFundamental:
   case UTT_IsObject:
   case UTT_IsScalar:
if (!T->isVariableArrayType()) {
       return T->isIncompleteArrayType();
     }
 
     Self.Diag(KeyLoc, diag::err_vla_unsupported)
         << 1 << tok::kw___is_unbounded_array;
     return false;
   case UTT_IsPointer:
     return T->isAnyPointerType();
+  case UTT_IsNullPointer:
+    return T->isNullPtrType();
   case UTT_IsLvalueReference:
     return T->isLValueReferenceType();
   case UTT_IsRvalueReference:
     return T->isRValueReferenceType();
   case UTT_IsMemberFunctionPointer:
     return T->isMemberFunctionPointerType();
   case UTT_IsMemberObjectPointer:
     return T->isMemberDataPointerType();
   case UTT_IsEnum:
     return T->isEnumeralType();
+  case UTT_IsScopedEnum:
+    return T->isScopedEnumeralType();
   case UTT_IsUnion:
     return T->isUnionType();
   case UTT_IsClass:
     return T->isClassType() || T->isStructureType() || T->isInterfaceType();
   case UTT_IsFunction:
     return T->isFunctionType();
 
     // Type trait expressions which correspond to the convenient composition
case UTT_IsCompleteType:
     // http://docwiki.embarcadero.com/RADStudio/XE/en/Is_complete_type_(typename_T_):
     //   Returns True if and only if T is a complete type at the point of the
     //   function call.
     return !T->isIncompleteType();
   case UTT_HasUniqueObjectRepresentations:
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
+  case UTT_IsReferenceable:
+    return T.isReferenceable();
   }
 }
 
 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
                                     QualType RhsT, SourceLocation KeyLoc);
 
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,

clang/test/SemaCXX/type-traits.cpp

void is_union()
   { int arr[F(__is_union(IntAr))]; }
   { int arr[F(__is_union(UnionAr))]; }
   { int arr[F(__is_union(cvoid))]; }
   { int arr[F(__is_union(IntArNB))]; }
   { int arr[F(__is_union(HasAnonymousUnion))]; }
 }
 
 typedef Enum EnumType;
+typedef EnumClass EnumClassType;
 
 void is_enum()
 {
   { int arr[T(__is_enum(Enum))]; }
   { int arr[T(__is_enum(EnumType))]; }
+  { int arr[T(__is_enum(SignedEnum))]; }
+  { int arr[T(__is_enum(UnsignedEnum))]; }
+
+  { int arr[T(__is_enum(EnumClass))]; }
+  { int arr[T(__is_enum(EnumClassType))]; }
+  { int arr[T(__is_enum(SignedEnumClass))]; }
+  { int arr[T(__is_enum(UnsignedEnumClass))]; }
 
   { int arr[F(__is_enum(int))]; }
   { int arr[F(__is_enum(Union))]; }
   { int arr[F(__is_enum(Int))]; }
   { int arr[F(__is_enum(IntAr))]; }
   { int arr[F(__is_enum(UnionAr))]; }
   { int arr[F(__is_enum(Derives))]; }
   { int arr[F(__is_enum(ClassType))]; }
   { int arr[F(__is_enum(cvoid))]; }
   { int arr[F(__is_enum(IntArNB))]; }
   { int arr[F(__is_enum(HasAnonymousUnion))]; }
+  { int arr[F(__is_enum(AnIncompleteType))]; }
+  { int arr[F(__is_enum(AnIncompleteTypeAr))]; }
+  { int arr[F(__is_enum(AnIncompleteTypeArMB))]; }
+  { int arr[F(__is_enum(AnIncompleteTypeArNB))]; }
+}
+
+void is_scoped_enum() {
+  static_assert(!__is_scoped_enum(Enum), "");
+  static_assert(!__is_scoped_enum(EnumType), "");
+  static_assert(!__is_scoped_enum(SignedEnum), "");
+  static_assert(!__is_scoped_enum(UnsignedEnum), "");
+
+  static_assert(__is_scoped_enum(EnumClass), "");
+  static_assert(__is_scoped_enum(EnumClassType), "");
+  static_assert(__is_scoped_enum(SignedEnumClass), "");
+  static_assert(__is_scoped_enum(UnsignedEnumClass), "");
+
+  static_assert(!__is_scoped_enum(int), "");
+  static_assert(!__is_scoped_enum(Union), "");
+  static_assert(!__is_scoped_enum(Int), "");
+  static_assert(!__is_scoped_enum(IntAr), "");
+  static_assert(!__is_scoped_enum(UnionAr), "");
+  static_assert(!__is_scoped_enum(Derives), "");
+  static_assert(!__is_scoped_enum(ClassType), "");
+  static_assert(!__is_scoped_enum(cvoid), "");
+  static_assert(!__is_scoped_enum(IntArNB), "");
+  static_assert(!__is_scoped_enum(HasAnonymousUnion), "");
+  static_assert(!__is_scoped_enum(AnIncompleteType), "");
+  static_assert(!__is_scoped_enum(AnIncompleteTypeAr), "");
+  static_assert(!__is_scoped_enum(AnIncompleteTypeArMB), "");
+  static_assert(!__is_scoped_enum(AnIncompleteTypeArNB), "");
 }
 
 struct FinalClass final {
 };
 
 template<typename T>
 struct PotentiallyFinal { };
 
 template<typename T>
 struct PotentiallyFinal<T*> final { };
 
void is_unbounded_array(int n) {
   static_assert(!__is_unbounded_array(Enum), "");
   static_assert(!__is_unbounded_array(void *), "");
   static_assert(!__is_unbounded_array(cvoid *), "");
 
   int t32[n];
   (void)__is_unbounded_array(decltype(t32)); // expected-error{{variable length arrays are not supported for '__is_unbounded_array'}}
 }
 
+void is_referenceable() {
+  static_assert(__is_referenceable(int), "");
+  static_assert(__is_referenceable(const int), "");
+  static_assert(__is_referenceable(volatile int), "");
+  static_assert(__is_referenceable(const volatile int), "");
+  static_assert(__is_referenceable(int *), "");
+  static_assert(__is_referenceable(int &), "");
+  static_assert(__is_referenceable(int &&), "");
+  static_assert(__is_referenceable(int (*)()), "");
+  static_assert(__is_referenceable(int (&)()), "");
+  static_assert(__is_referenceable(int(&&)()), "");
+  static_assert(__is_referenceable(IntAr), "");
+  static_assert(__is_referenceable(IntArNB), "");
+  static_assert(__is_referenceable(decltype(nullptr)), "");
+  static_assert(__is_referenceable(Empty), "");
+  static_assert(__is_referenceable(Union), "");
+  static_assert(__is_referenceable(Derives), "");
+  static_assert(__is_referenceable(Enum), "");
+  static_assert(__is_referenceable(EnumClass), "");
+  static_assert(__is_referenceable(int Empty::*), "");
+  static_assert(__is_referenceable(int(Empty::*)()), "");
+  static_assert(__is_referenceable(AnIncompleteType), "");
+  static_assert(__is_referenceable(struct AnIncompleteType), "");
+
+  using function_type = void(int);
+  static_assert(__is_referenceable(function_type), "");
+
+  static_assert(!__is_referenceable(void), "");
+}
+
 template <typename T> void tmpl_func(T&) {}
 
 template <typename T> struct type_wrapper {
   typedef T type;
   typedef T* ptrtype;
   typedef T& reftype;
 };
 
void is_pointer()
   int t29[F(__is_pointer(IntArNB))];
   int t30[F(__is_pointer(Union))];
   int t31[F(__is_pointer(UnionAr))];
   int t32[F(__is_pointer(StructWithMembers))];
   int t33[F(__is_pointer(int StructWithMembers::*))];
   int t34[F(__is_pointer(void (StructWithMembers::*) ()))];
 }
 
+void is_null_pointer() {
+  StructWithMembers x;
+
+  static_assert(__is_nullptr(decltype(nullptr)), "");
+  static_assert(!__is_nullptr(void *), "");
+  static_assert(!__is_nullptr(cvoid *), "");
+  static_assert(!__is_nullptr(cvoid *), "");
+  static_assert(!__is_nullptr(char *), "");
+  static_assert(!__is_nullptr(int *), "");
+  static_assert(!__is_nullptr(int **), "");
+  static_assert(!__is_nullptr(ClassType *), "");
+  static_assert(!__is_nullptr(Derives *), "");
+  static_assert(!__is_nullptr(Enum *), "");
+  static_assert(!__is_nullptr(IntArNB *), "");
+  static_assert(!__is_nullptr(Union *), "");
+  static_assert(!__is_nullptr(UnionAr *), "");
+  static_assert(!__is_nullptr(StructWithMembers *), "");
+  static_assert(!__is_nullptr(void (*)()), "");
+
+  static_assert(!__is_nullptr(void), "");
+  static_assert(!__is_nullptr(cvoid), "");
+  static_assert(!__is_nullptr(cvoid), "");
+  static_assert(!__is_nullptr(char), "");
+  static_assert(!__is_nullptr(int), "");
+  static_assert(!__is_nullptr(int), "");
+  static_assert(!__is_nullptr(ClassType), "");
+  static_assert(!__is_nullptr(Derives), "");
+  static_assert(!__is_nullptr(Enum), "");
+  static_assert(!__is_nullptr(IntArNB), "");
+  static_assert(!__is_nullptr(Union), "");
+  static_assert(!__is_nullptr(UnionAr), "");
+  static_assert(!__is_nullptr(StructWithMembers), "");
+  static_assert(!__is_nullptr(int StructWithMembers::*), "");
+  static_assert(!__is_nullptr(void(StructWithMembers::*)()), "");
+}
+
 void is_member_object_pointer()
 {
   StructWithMembers x;
 
   int t01[T(__is_member_object_pointer(int StructWithMembers::*))];
 
   int t10[F(__is_member_object_pointer(void (StructWithMembers::*) ()))];
   int t11[F(__is_member_object_pointer(void*))];
void check_remove_cvref() {
   static_assert(__is_same(remove_cvref_t<const volatile S &&>, S), "");
   static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*), "");
   static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()), "");
   static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &), "");
   static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&), "");
 }
 
 template <class T> using decay_t = __decay(T);
-template <class T> struct dne;
 
 void check_decay() {
   static_assert(__is_same(decay_t<void>, void), "");
   static_assert(__is_same(decay_t<const volatile void>, void), "");
   static_assert(__is_same(decay_t<int>, int), "");
   static_assert(__is_same(decay_t<const int>, int), "");
   static_assert(__is_same(decay_t<volatile int>, int), "");
   static_assert(__is_same(decay_t<const volatile int>, int), "");
static void checks() {
     static_assert(__is_same(add_rvalue_reference_t<M>, M), "");
     static_assert(__is_same(decay_t<M>, M), "");
     static_assert(__is_same(remove_const_t<M>, M), "");
     static_assert(__is_same(remove_volatile_t<M>, M), "");
     static_assert(__is_same(remove_cv_t<M>, M), "");
     static_assert(__is_same(remove_cvref_t<M>, M), "");
     static_assert(__is_same(remove_pointer_t<M>, M), "");
     static_assert(__is_same(remove_reference_t<M>, M), "");
+
+    static_assert(!__is_referenceable(M), "");
   }
 };
 
 void check_abominable_function() {
   { CheckAbominableFunction<int (S::*)() &> x; }
   { CheckAbominableFunction<int (S::*)() &&> x; }
   { CheckAbominableFunction<int (S::*)() const> x; }
   { CheckAbominableFunction<int (S::*)() const &> x; }