[libc++] Extend is_always_bitcastable for pointers and enums

[ldionne]

CC @var-const

libcxx/include/__type_traits/is_always_bitcastable.h

40–42

WDYT?

73

87

88–90

And then remove the line you added below.

libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp

61

Can you please also add tests for copy and move that use these types? This is a really fundamental part of the library so we want to make sure our tests in that area are bomb proof.

libcxx/include/__type_traits/is_always_bitcastable.h

 #define _LIBCPP___TYPE_TRAITS_IS_ALWAYS_BITCASTABLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_object.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_trivially_copyable.h>
+#include <__type_traits/is_void.h>
 #include <__type_traits/remove_cv.h>
+#include <__type_traits/remove_pointer.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <class _From, class _To, class = void>
+struct __is_always_bitcastable_pointer {
+  static const bool value = false;
+};
+
+template <class _From, class _To>
+struct __is_always_bitcastable_pointer<_From,
+                                       _To,
+                                       __enable_if_t<is_pointer<_From>::value && is_pointer<_To>::value> > {
+  using _UnqualFrom = __remove_cv_t<__remove_pointer_t<_From> >;
+  using _UnqualTo = __remove_cv_t<__remove_pointer_t<_To> >;
+
+  static const bool value =
+      (sizeof(_From) == sizeof(_To)) && is_object<_UnqualFrom>::value && is_object<_UnqualTo>::value &&
+      (is_same<_UnqualFrom, _UnqualTo>::value || is_void<_UnqualFrom>::value || is_void<_UnqualTo>::value);
+};
+
 // Checks whether an object of type `From` can always be bit-cast to an object of type `To` and represent a valid value
 // of type `To`. In other words, `From` and `To` have the same value representation and the set of values of `From` is
 // a subset of the set of values of `To`.
 //
 // Note that types that cannot be assigned to each other using built-in assignment (e.g. arrays) might still be
 // considered bit-castable.
 template <class _From, class _To>
 struct __is_always_bitcastable {
static const bool value =
     //   integer, where a large positive value of the unsigned integer corresponds to a negative value in the signed
     //   integer type), the value of `To` that results from a bitwise copy of `From` is the same what would be produced
     //   by the built-in assignment (if it were defined for the two types, to which there are minor exceptions, e.g.
     //   built-in arrays).
     //
     // In practice, that means:
     // - all integral types (except `bool`, see below) -- that is, character types and `int` types, both signed and
     //   unsigned...
+    // - enumerations to integral types...
     // - as well as arrays of such types...
     // - ...that have the same size.
+    // - pointers to the same cv-qualified type or void
     //
     // Other trivially-copyable types can't be validly bit-cast outside of their own type:
     // - floating-point types normally have different sizes and thus aren't bit-castable between each other (fails #1);
     // - integral types and floating-point types use different representations, so for example bit-casting an integral
     //   `1` to `float` results in a very small less-than-one value, unlike built-in assignment that produces `1.0`
     //   (fails #2);
     // - booleans normally use only a single bit of their object representation; bit-casting an integer to a boolean
     //   will result in a boolean object with an incorrect representation, which is undefined behavior (fails #2).
     //   Bit-casting from a boolean into an integer, however, is valid;
-    // - enumeration types may have different ranges of possible values (fails #1);
+    // - enumeration types may have different ranges of possible values (fails #1)
+    //   enumerations to integers of the same size are valid
     // - for pointers, it is not guaranteed that pointers to different types use the same set of values to represent
     //   addresses, and the conversion results are explicitly unspecified for types with different alignments
     //   (fails #1);
     // - for structs and unions it is impossible to determine whether the set of values of one of them is a subset of
     //   the other (fails #1);
+    // - pointers to base classes may have different value representations (e.g. virtual bases) (fails #1)
     // - there is no need to consider `nullptr_t` for practical purposes.
     (
       sizeof(_From) == sizeof(_To) &&
-      is_integral<_From>::value &&
+      (is_integral<_From>::value || is_enum<_From>::value) &&
       is_integral<_To>::value &&
       !is_same<_UnqualTo, bool>::value
-    );
+    ) || __is_always_bitcastable_pointer<_From, _To>::value;
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_ALWAYS_BITCASTABLE_H

libcxx/test/libcxx/type_traits/is_always_bitcastable.compile.pass.cpp

 template <bool Expected, class Types1, class Types2 = Types1>
 constexpr void check() {
   meta::for_each(Types1{}, []<class T>() {
     meta::for_each(Types2{}, []<class U>() {
       check_with_cv<Expected, T, U>();
     });
   });
 }
 
 template <bool Expected, class Types1, class Types2>
 constexpr void check_both_ways() {
   check<Expected, Types1, Types2>();
   check<Expected, Types2, Types1>();
 }
 
 constexpr void test() {
+  // lists of integrals with specific size
+  using integral_8 = meta::type_list<char8_t, int8_t, uint8_t>;
+
+  using integral_16 = meta::type_list<
+#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
+      wchar_t,
+#endif
+      char16_t,
+      int16_t,
+      uint16_t>;
+
+  using integral_32 = meta::type_list<
+#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
+      wchar_t,
+#endif
+      char32_t,
+      int32_t,
+      uint32_t>;
+  using integral_64 = meta::type_list<int64_t, uint64_t>;
+
   // Arithmetic types.
   {
     // Bit-castable arithmetic types.
 
     // 8-bit types.
-    using integral_8 = meta::type_list<char8_t, int8_t, uint8_t>;
     using chars = meta::type_list<char, unsigned char, signed char>;
 #if CHAR_BIT == 8
     check<true, meta::concatenate_t<integral_8, chars>>();
 #else
     check<true, integral_8>();
     check<true, chars>();
 #endif
 
     // 16-bit types.
-    using integral_16 = meta::type_list<char16_t, int16_t, uint16_t>;
-#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 16
-    check<true, meta::concatenate_t<integral_16, meta::type_list<wchar_t>>>();
-#else
     check<true, integral_16>();
-#endif
 
     // 32-bit types.
-    using integral_32 = meta::type_list<char32_t, int32_t, uint32_t>;
-#if !defined(TEST_HAS_NO_WIDE_CHARACTERS) && __WCHAR_WIDTH__ == 32
-    check<true, meta::concatenate_t<integral_32, meta::type_list<wchar_t>>>();
-#else
     check<true, integral_32>();
-#endif
 
     // 64-bit types.
-    using integral_64 = meta::type_list<int64_t, uint64_t>;
     check<true, integral_64>();
 
     // 128-bit types.
 #ifndef TEST_HAS_NO_INT128
     check<true, meta::type_list<__int128_t, __uint128_t>>();
 #endif
 
     // Bool.
// Enumerations.
     check_both_ways<false, meta::type_list<E1>, meta::type_list<E2>>();
 
     enum class ScopedE1 { Value1 };
     enum class ScopedE2 { Value1 };
     check<true, meta::type_list<ScopedE1>>();
     check_both_ways<false, meta::type_list<ScopedE1>, meta::type_list<ScopedE2>>();
   }
 
+  // Enumerations to integers
+  {
+    enum Enum : std::int32_t { Value };
+    check<true, meta::type_list<Enum>, integral_32>();
+
+    enum class ScopedEnum : std::int32_t { Value };
+    check<true, meta::type_list<ScopedEnum>, integral_32>();
+  }
+
   // Pointers.
   {
     check<true, meta::type_list<int*>>();
-    check_both_ways<false, meta::type_list<int*>, meta::type_list<const int*, long*, void*>>();
+    check_both_ways<false, meta::type_list<int*>, meta::type_list<long*>>();
+    check<true, meta::type_list<int*, const int*, volatile int*, const volatile int*>>();
 
     check<true, meta::type_list<FuncPtr1>>();
     check_both_ways<false, meta::type_list<FuncPtr1>, meta::type_list<FuncPtr2>>();
   }
 
   // Pointers to members.
   {
     struct S {
       int mem_obj1 = 0;
       long mem_obj2 = 0;
       void MemFunc1() {}
       int MemFunc2() { return 0; }
     };
     using MemObjPtr1 = decltype(&S::mem_obj1);
+    using ConstMemObjPtr1 = const int S::*;
     using MemObjPtr2 = decltype(&S::mem_obj2);
     using MemFuncPtr1 = decltype(&S::MemFunc1);
+    using ConstMemFuncPtr1 = void(S::*)() const;
     using MemFuncPtr2 = decltype(&S::MemFunc2);
 
     check<true, meta::type_list<MemObjPtr1>>();
+    check<false, meta::type_list<MemObjPtr1>, meta::type_list<ConstMemObjPtr1>>();
     check<true, meta::type_list<MemFuncPtr1>>();
+    check<false, meta::type_list<MemFuncPtr1>, meta::type_list<ConstMemFuncPtr1>>();
     check_both_ways<false, meta::type_list<MemObjPtr1>, meta::type_list<MemObjPtr2>>();
     check_both_ways<false, meta::type_list<MemFuncPtr1>, meta::type_list<MemFuncPtr2>>();
   }
 
   // Trivial classes.
   {
     struct S1 {};
     check<true, meta::type_list<S1>>();