Expanded type_traits and switched __has_feature to __has_builtin

Author: ZERICO2005

src/libcxx/header_test.cpp

@@ -1,4 +1,5 @@
 #include <__config>
+#include <algorithm>
 #include <bit>
 #include <cassert>
 #include <cctype>

src/libcxx/include/type_traits

@@ -38,10 +38,21 @@ template<class...> using void_t = void;
 
 template<class...> using __require = true_type;
 
+// type relationships:
 template<class, class> struct is_same           : false_type {};
 template<class _Tp>    struct is_same<_Tp, _Tp> : true_type  {};
 template<class _Lp, class _Rp> inline constexpr bool is_same_v = is_same<_Lp, _Rp>::value;
 
+#if __has_builtin(__is_base_of)
+template<class _Lp, class _Rp> inline constexpr bool is_base_of_v = __is_base_of(_Lp, _Rp);
+template<class _Lp, class _Rp> using is_base_of = bool_constant<is_base_of_v<_Lp, _Rp>>;
+#endif
+
+#if __has_builtin(__is_convertible)
+template<class _Lp, class _Rp> inline constexpr bool is_convertible_v = __is_convertible(_Lp, _Rp);
+template<class _Lp, class _Rp> using is_convertible = bool_constant<is_convertible_v<_Lp, _Rp>>;
+#endif
+
 // logical operator traits:
 template<class...>                struct conjunction              : true_type                                           {};
 template<class _Tp>               struct conjunction<_Tp>         : _Tp                                                 {};
@@ -77,6 +88,23 @@ template<class>     struct is_volatile               : false_type {};
 template<class _Tp> struct is_volatile<_Tp volatile> : true_type  {};
 template<class _Tp> inline constexpr bool is_volatile_v = is_volatile<_Tp>::value;
 
+template<class>     struct is_lvalue_reference       : false_type {};
+template<class _Tp> struct is_lvalue_reference<_Tp&> : true_type  {};
+template<class _Tp> inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
+
+template<class>     struct is_rvalue_reference        : false_type {};
+template<class _Tp> struct is_rvalue_reference<_Tp&&> : true_type  {};
+template<class _Tp> inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
+
+template<class _Tp> using is_reference = disjunction<is_lvalue_reference<_Tp>, is_rvalue_reference<_Tp>>;
+template<class _Tp> inline constexpr bool is_reference_v = is_reference<_Tp>::value;
+
+template<class _Tp>            struct __member_pointer             : false_type {};
+template<class _Tp, class _Cp> struct __member_pointer<_Tp _Cp::*> : true_type  {};
+template<class _Tp> using is_member_pointer = __member_pointer<remove_cv_t<_Tp>>;
+template<class _Tp> inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
+
+// primary type categories:
 template<class _Tp> using is_void = is_same<remove_cv_t<_Tp>, void>;
 template<class _Tp> inline constexpr bool is_void_v = is_void<_Tp>::value;
 
@@ -114,134 +142,135 @@ template<>          struct __floating_point<long double> : true_type  {};
 template<class _Tp> using is_floating_point = __floating_point<remove_cv_t<_Tp>>;
 template<class _Tp> inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
 
-template<class _Tp> using is_arithmetic = disjunction<is_integral<_Tp>, is_floating_point<_Tp>>;
-template<class _Tp> inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
-
-template<class _Tp> using is_fundamental = disjunction<is_void<_Tp>, is_null_pointer<_Tp>, is_arithmetic<_Tp>>;
-template<class _Tp> inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
-
-template<class _Tp> struct is_compound : std::integral_constant<bool, !std::is_fundamental<_Tp>::value> {};
-template<class _Tp> inline constexpr bool is_compound_v = is_compound<_Tp>::value;
-
-template<class _Tp, bool = is_arithmetic<_Tp>::value> struct __is_signed : integral_constant<bool, _Tp(-1) < _Tp(0)> {};
-template<class _Tp>                                   struct __is_signed<_Tp, false> : false_type {};
-template<class _Tp> struct is_signed : __is_signed<_Tp>::type {};
-template<class _Tp> constexpr bool is_signed_v = is_signed<_Tp>::value;
-
-template<class _Tp, bool = is_arithmetic<_Tp>::value> struct __is_unsigned : integral_constant<bool, _Tp(0) < _Tp(-1)> {};
-template<class _Tp>                                   struct __is_unsigned<_Tp, false> : false_type {};
-template<class _Tp> struct is_unsigned : __is_unsigned<_Tp>::type {};
-template<class _Tp> constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
-
-template<class>                 struct is_array           : false_type {};
-template<class _Tp>             struct is_array<_Tp[]>    : true_type  {};
-template<class _Tp, size_t _Np> struct is_array<_Tp[_Np]> : true_type  {};
-template<class _Tp> inline constexpr bool is_array_v = is_array<_Tp>::value;
+#if __has_builtin(__is_array)
+template<class _Tp> inline constexpr bool is_array_v = __is_array(_Tp);
+template<class _Tp> using is_array = bool_constant<is_array_v<_Tp>>;
+#endif
 
-#if __has_feature(is_enum)
+#if __has_builtin(__is_enum)
 template<class _Tp> inline constexpr bool is_enum_v = __is_enum(_Tp);
 template<class _Tp> using is_enum = bool_constant<is_enum_v<_Tp>>;
 #endif
 
-#if __has_feature(is_union)
+#if __has_builtin(__is_union)
 template<class _Tp> inline constexpr bool is_union_v = __is_union(_Tp);
 template<class _Tp> using is_union = bool_constant<is_union_v<_Tp>>;
 #endif
 
-#if __has_feature(is_class)
+#if __has_builtin(__is_class)
 template<class _Tp> inline constexpr bool is_class_v = __is_class(_Tp);
 template<class _Tp> using is_class = bool_constant<is_class_v<_Tp>>;
 #endif
 
-#if __has_feature(is_trivial)
+template<class _Tp> using is_function = negation<disjunction<is_const<_Tp const>, is_reference<_Tp>>>;
+template<class _Tp> inline constexpr bool is_function_v = is_function<_Tp>::value;
+
+template<class>     struct is_pointer       : false_type {};
+template<class _Tp> struct is_pointer<_Tp*> : true_type  {};
+template<class _Tp> inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
+
+template<class _Tp>            struct __member_function_pointer             : false_type       {};
+template<class _Tp, class _Cp> struct __member_function_pointer<_Tp _Cp::*> : is_function<_Tp> {};
+template<class _Tp> using is_member_function_pointer = __member_function_pointer<remove_cv_t<_Tp>>;
+template<class _Tp> inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
+
+template<class _Tp>            struct __member_object_pointer             : false_type                 {};
+template<class _Tp, class _Cp> struct __member_object_pointer<_Tp _Cp::*> : negation<is_function<_Tp>> {};
+template<class _Tp> using is_member_object_pointer = __member_object_pointer<remove_cv_t<_Tp>>;
+template<class _Tp> inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
+
+// composite type categories:
+
+template<class _Tp> using is_arithmetic = disjunction<is_integral<_Tp>, is_floating_point<_Tp>>;
+template<class _Tp> inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+
+template<class _Tp> using is_fundamental = disjunction<is_void<_Tp>, is_null_pointer<_Tp>, is_arithmetic<_Tp>>;
+template<class _Tp> inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
+
+template <class _Tp> struct is_scalar : public integral_constant<bool,
+    is_arithmetic<_Tp>::value ||
+    is_member_pointer<_Tp>::value ||
+    is_pointer<_Tp>::value ||
+    is_null_pointer<_Tp>::value ||
+    is_enum<_Tp>::value
+> {};
+template <class _Tp> inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+
+template <class _Tp> struct is_object : integral_constant<bool,
+    is_scalar<_Tp>::value ||
+    is_array<_Tp>::value ||
+    is_union<_Tp>::value ||
+    is_class<_Tp>::value
+> {};
+template <class _Tp> inline constexpr bool is_object_v = is_object<_Tp>::value;
+
+template<class _Tp> struct is_compound : std::integral_constant<bool, !std::is_fundamental<_Tp>::value> {};
+template<class _Tp> inline constexpr bool is_compound_v = is_compound<_Tp>::value;
+
+#if __has_builtin(__is_trivial)
 template<class _Tp> inline constexpr bool is_trivial_v = __is_trivial(_Tp);
 template<class _Tp> using is_trivial = bool_constant<is_trivial_v<_Tp>>;
 #endif
 
-#if __has_feature(is_trivially_copyable)
+#if __has_builtin(__is_trivially_copyable)
 template<class _Tp> inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
 template<class _Tp> using is_trivially_copyable = bool_constant<is_trivially_copyable_v<_Tp>>;
 #endif
 
-#if __has_feature(is_standard_layout)
+#if __has_builtin(__is_standard_layout)
 template<class _Tp> inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
 template<class _Tp> using is_standard_layout = bool_constant<is_standard_layout_v<_Tp>>;
 #endif
 
-#if __has_feature(is_pod)
+#if __has_builtin(__is_pod)
 template<class _Tp> inline constexpr bool is_pod_v = __is_pod(_Tp);
 template<class _Tp> using is_pod = bool_constant<is_pod_v<_Tp>>;
 #endif
 
-#if __has_feature(is_empty)
+#if __has_builtin(__is_literal_type)
+template<class _Tp> inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
+template<class _Tp> using is_literal_type = bool_constant<is_literal_type_v<_Tp>>;
+#endif
+
+#if __has_builtin(__has_unique_object_representations)
+template<class _Tp> inline constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Tp);
+template<class _Tp> using has_unique_object_representations = bool_constant<has_unique_object_representations_v<_Tp>>;
+#endif
+
+#if __has_builtin(__is_empty)
 template<class _Tp> inline constexpr bool is_empty_v = __is_empty(_Tp);
 template<class _Tp> using is_empty = bool_constant<is_empty_v<_Tp>>;
 #endif
 
-#if __has_feature(is_polymorphic)
+#if __has_builtin(__is_polymorphic)
 template<class _Tp> inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp);
 template<class _Tp> using is_polymorphic = bool_constant<is_polymorphic_v<_Tp>>;
 #endif
 
-#if __has_feature(is_abstract)
+#if __has_builtin(__is_abstract)
 template<class _Tp> inline constexpr bool is_abstract_v = __is_abstract(_Tp);
 template<class _Tp> using is_abstract = bool_constant<is_abstract_v<_Tp>>;
 #endif
 
-#if __has_feature(is_final)
+#if __has_builtin(__is_final)
 template<class _Tp> inline constexpr bool is_final_v = __is_final(_Tp);
 template<class _Tp> using is_final = bool_constant<is_final_v<_Tp>>;
 #endif
 
-template<class>     struct is_pointer       : false_type {};
-template<class _Tp> struct is_pointer<_Tp*> : true_type  {};
-template<class _Tp> inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
-
-template<class>     struct is_lvalue_reference       : false_type {};
-template<class _Tp> struct is_lvalue_reference<_Tp&> : true_type  {};
-template<class _Tp> inline constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
-
-template<class>     struct is_rvalue_reference        : false_type {};
-template<class _Tp> struct is_rvalue_reference<_Tp&&> : true_type  {};
-template<class _Tp> inline constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
-
-template<class _Tp> using is_reference = disjunction<is_lvalue_reference<_Tp>, is_rvalue_reference<_Tp>>;
-template<class _Tp> inline constexpr bool is_reference_v = is_reference<_Tp>::value;
-
-template<class _Tp> using is_function = negation<disjunction<is_const<_Tp const>, is_reference<_Tp>>>;
-template<class _Tp> inline constexpr bool is_function_v = is_function<_Tp>::value;
-
-template<class _Tp>            struct __member_pointer             : false_type {};
-template<class _Tp, class _Cp> struct __member_pointer<_Tp _Cp::*> : true_type  {};
-template<class _Tp> using is_member_pointer = __member_pointer<remove_cv_t<_Tp>>;
-template<class _Tp> inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
-
-template<class _Tp>            struct __member_function_pointer             : false_type       {};
-template<class _Tp, class _Cp> struct __member_function_pointer<_Tp _Cp::*> : is_function<_Tp> {};
-template<class _Tp> using is_member_function_pointer = __member_function_pointer<remove_cv_t<_Tp>>;
-template<class _Tp> inline constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
-
-template<class _Tp>            struct __member_object_pointer             : false_type                 {};
-template<class _Tp, class _Cp> struct __member_object_pointer<_Tp _Cp::*> : negation<is_function<_Tp>> {};
-template<class _Tp> using is_member_object_pointer = __member_object_pointer<remove_cv_t<_Tp>>;
-template<class _Tp> inline constexpr bool is_member_object_pointer_v = is_member_object_pointer<_Tp>::value;
+#if __has_builtin(__is_aggregate)
+template<class _Tp> inline constexpr bool is_aggregate_v = __is_aggregate(_Tp);
+template<class _Tp> using is_aggregate = bool_constant<is_aggregate_v<_Tp>>;
+#endif
 
-template <class _Tp> struct is_scalar : public integral_constant<bool,
-    is_arithmetic<_Tp>::value ||
-    is_member_pointer<_Tp>::value ||
-    is_pointer<_Tp>::value ||
-    is_null_pointer<_Tp>::value ||
-    is_enum<_Tp>::value
-> {};
-template <class _Tp> inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+#if __has_builtin(__is_signed)
+template<class _Tp> inline constexpr bool is_signed_v = __is_signed(_Tp);
+template<class _Tp> using is_signed = bool_constant<is_signed_v<_Tp>>;
+#endif
 
-template <class _Tp> struct is_object : integral_constant<bool,
-    is_scalar<_Tp>::value ||
-    is_array<_Tp>::value ||
-    is_union<_Tp>::value ||
-    is_class<_Tp>::value
-> {};
-template <class _Tp> inline constexpr bool is_object_v = is_object<_Tp>::value;
+#if __has_builtin(__is_unsigned)
+template<class _Tp> inline constexpr bool is_unsigned_v = __is_unsigned(_Tp);
+template<class _Tp> using is_unsigned = bool_constant<is_unsigned_v<_Tp>>;
+#endif
 
 // const/volatile addition traits:
 template<class _Tp> using add_const = conditional<disjunction_v<is_reference<_Tp>, is_function<_Tp>, is_const<_Tp>>,
@@ -341,6 +370,17 @@ public:
 };
 template <class _Tp> using decay_t = typename decay<_Tp>::type;
 
+// underlying_type:
+
+#if __has_builtin(__underlying_type)
+template<class _Tp, bool = is_enum<_Tp>::value> struct __underlying_type_impl;
+template<class _Tp> struct __underlying_type_impl<_Tp, false> {};
+template<class _Tp> struct __underlying_type_impl<_Tp, true> { typedef __underlying_type(_Tp) type; };
+
+template<class _Tp> struct underlying_type  : __underlying_type_impl<_Tp, is_enum<_Tp>::value> {};
+template<class _Tp> using underlying_type_t = typename underlying_type<_Tp>::type;
+#endif
+
 // <utility> functions:
 template<class _Tp> add_rvalue_reference_t<_Tp> declval() noexcept;
 
@@ -350,7 +390,7 @@ template<class, class...>         auto __constructible(...) -> false_type;
 template<class _Tp, class... _As> using is_constructible = decltype(__constructible<_Tp, _As...>(0));
 template<class _Tp, class... _As> inline constexpr bool is_constructible_v = is_constructible<_Tp, _As...>::value;
 
-#if __has_feature(is_trivially_constructible)
+#if __has_builtin(__is_trivially_constructible)
 template<class _Tp, class... _As> inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _As...);
 template<class _Tp, class... _As> using is_trivially_constructible = bool_constant<is_trivially_constructible_v<_Tp, _As...>>;
 #endif
@@ -392,13 +432,19 @@ template<class, class>         auto __assignable(...) -> false_type;
 template<class _Lp, class _Rp> using is_assignable = decltype(__assignable<_Lp, _Rp>(0));
 template<class _Lp, class _Rp> inline constexpr bool is_assignable_v = is_assignable<_Lp, _Rp>::value;
 
+#if __has_builtin(__is_trivially_assignable)
+template<class _Lp, class _Rp> inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Lp, _Rp);
+template<class _Lp, class _Rp> using is_trivially_assignable = bool_constant<is_trivially_assignable_v<_Lp, _Rp>>;
+#endif
+
 template<class _Lp, class _Rp> auto __nt_assignable(int) -> enable_if_t<noexcept(declval<_Lp>() = declval<_Rp>()), true_type>;
 template<class, class>         auto __nt_assignable(...) -> false_type;
 template<class _Lp, class _Rp> using is_nothrow_assignable = decltype(__nt_assignable<_Lp, _Rp>(0));
 template<class _Lp, class _Rp> inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Lp, _Rp>::value;
 
 template<class _Tp> using is_copy_assignable = is_assignable<add_lvalue_reference_t<_Tp>,
                                                              add_lvalue_reference_t<add_const_t<_Tp>>>;
+
 template<class _Tp> inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
 
 template<class _Tp> using is_nothrow_copy_assignable = is_nothrow_assignable<add_lvalue_reference_t<_Tp>,
@@ -413,7 +459,17 @@ template<class _Tp> using is_nothrow_move_assignable = is_nothrow_assignable<add
                                                                              add_rvalue_reference_t<_Tp>>;
 template<class _Tp> inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
 
-#if __has_feature(has_virtual_destructor)
+#if __has_builtin(__is_destructible)
+template<class _Tp> inline constexpr bool is_destructible_v = __is_destructible(_Tp);
+template<class _Tp> using is_destructible = bool_constant<is_destructible_v<_Tp>>;
+#endif
+
+#if __has_builtin(__is_trivially_destructible)
+template<class _Tp> inline constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Tp);
+template<class _Tp> using is_trivially_destructible = bool_constant<is_trivially_destructible_v<_Tp>>;
+#endif
+
+#if __has_builtin(__has_virtual_destructor)
 template<class _Tp> inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp);
 template<class _Tp> using has_virtual_destructor = bool_constant<has_virtual_destructor_v<_Tp>>;
 #endif

src/libcxx/include/version

@@ -53,11 +53,11 @@
 // # define __cpp_lib_filesystem                           201703L
 // # define __cpp_lib_gcd_lcm                              201606L
 // # define __cpp_lib_hardware_interference_size           201703L
-// # define __cpp_lib_has_unique_object_representations    201606L
+# define __cpp_lib_has_unique_object_representations    201606L
 # define __cpp_lib_hypot                                201603L
 // # define __cpp_lib_incomplete_container_elements        201505L
 // # define __cpp_lib_invoke                               201411L
-// # define __cpp_lib_is_aggregate                         201703L
+# define __cpp_lib_is_aggregate                         201703L
 // # define __cpp_lib_is_invocable                         201703L
 // # define __cpp_lib_is_swappable                         201603L
 // # define __cpp_lib_launder                              201606L