diff --git a/libcxx/include/__type_traits/add_lvalue_reference.h b/libcxx/include/__type_traits/add_lvalue_reference.h
--- a/libcxx/include/__type_traits/add_lvalue_reference.h
+++ b/libcxx/include/__type_traits/add_lvalue_reference.h
@@ -18,11 +18,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl            { typedef _LIBCPP_NODEBUG _Tp  type; };
+#if __has_builtin(__add_lvalue_reference)
+template <class _Tp> struct add_lvalue_reference { typedef _LIBCPP_NODEBUG __add_lvalue_reference(_Tp) type; };
+#else
+template <class _Tp, bool = __referenceable<_Tp>::value> struct __add_lvalue_reference_impl            { typedef _LIBCPP_NODEBUG _Tp  type; };
 template <class _Tp                                       > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp& type; };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
 {typedef _LIBCPP_NODEBUG typename  __add_lvalue_reference_impl<_Tp>::type type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
diff --git a/libcxx/include/__type_traits/add_pointer.h b/libcxx/include/__type_traits/add_pointer.h
--- a/libcxx/include/__type_traits/add_pointer.h
+++ b/libcxx/include/__type_traits/add_pointer.h
@@ -21,8 +21,11 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__add_pointer)
+template <class _Tp> struct add_pointer { typedef _LIBCPP_NODEBUG __add_pointer(_Tp) type; };
+#else
 template <class _Tp,
-        bool = __is_referenceable<_Tp>::value ||
+        bool = __referenceable<_Tp>::value ||
                 _IsSame<typename remove_cv<_Tp>::type, void>::value>
 struct __add_pointer_impl
     {typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type;};
@@ -31,6 +34,7 @@
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
     {typedef _LIBCPP_NODEBUG typename __add_pointer_impl<_Tp>::type type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
diff --git a/libcxx/include/__type_traits/add_rvalue_reference.h b/libcxx/include/__type_traits/add_rvalue_reference.h
--- a/libcxx/include/__type_traits/add_rvalue_reference.h
+++ b/libcxx/include/__type_traits/add_rvalue_reference.h
@@ -18,11 +18,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl            { typedef _LIBCPP_NODEBUG _Tp   type; };
+#if __has_builtin(__add_rvalue_reference)
+template <class _Tp> struct add_rvalue_reference { typedef _LIBCPP_NODEBUG __add_rvalue_reference(_Tp) type; };
+#else
+template <class _Tp, bool = __referenceable<_Tp>::value> struct __add_rvalue_reference_impl            { typedef _LIBCPP_NODEBUG _Tp   type; };
 template <class _Tp                                       > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG _Tp&& type; };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
 {typedef _LIBCPP_NODEBUG typename __add_rvalue_reference_impl<_Tp>::type type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
diff --git a/libcxx/include/__type_traits/decay.h b/libcxx/include/__type_traits/decay.h
--- a/libcxx/include/__type_traits/decay.h
+++ b/libcxx/include/__type_traits/decay.h
@@ -26,6 +26,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__decay)
+template <class _Tp> struct decay { typedef _LIBCPP_NODEBUG __decay(_Tp) type; };
+#else
 template <class _Up, bool>
 struct __decay {
     typedef _LIBCPP_NODEBUG typename remove_cv<_Up>::type type;
@@ -53,8 +56,9 @@
 private:
     typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type _Up;
 public:
-    typedef _LIBCPP_NODEBUG typename __decay<_Up, __is_referenceable<_Up>::value>::type type;
+    typedef _LIBCPP_NODEBUG typename __decay<_Up, __referenceable<_Up>::value>::type type;
 };
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using decay_t = typename decay<_Tp>::type;
diff --git a/libcxx/include/__type_traits/is_referenceable.h b/libcxx/include/__type_traits/is_referenceable.h
--- a/libcxx/include/__type_traits/is_referenceable.h
+++ b/libcxx/include/__type_traits/is_referenceable.h
@@ -19,14 +19,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __is_referenceable_impl {
+#if __has_builtin(__is_referenceable)
+template <class _Tp>
+struct __referenceable : integral_constant<bool, __is_referenceable(_Tp)> {};
+#else
+struct __referenceable_impl {
     template <class _Tp> static _Tp& __test(int);
     template <class _Tp> static false_type __test(...);
 };
 
 template <class _Tp>
-struct __is_referenceable : integral_constant<bool,
-    _IsNotSame<decltype(__is_referenceable_impl::__test<_Tp>(0)), false_type>::value> {};
+struct __referenceable : integral_constant<bool,
+    _IsNotSame<decltype(__referenceable_impl::__test<_Tp>(0)), false_type>::value> {};
+#endif
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/libcxx/include/__type_traits/make_signed.h b/libcxx/include/__type_traits/make_signed.h
--- a/libcxx/include/__type_traits/make_signed.h
+++ b/libcxx/include/__type_traits/make_signed.h
@@ -23,6 +23,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__make_signed)
+template <class _Tp> struct make_signed { typedef _LIBCPP_NODEBUG __make_signed(_Tp) type; };
+#else
 typedef
     __type_list<signed char,
     __type_list<signed short,
@@ -66,6 +69,7 @@
 {
     typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
 };
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
diff --git a/libcxx/include/__type_traits/make_unsigned.h b/libcxx/include/__type_traits/make_unsigned.h
--- a/libcxx/include/__type_traits/make_unsigned.h
+++ b/libcxx/include/__type_traits/make_unsigned.h
@@ -25,6 +25,9 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__make_unsigned)
+template <class _Tp> struct make_unsigned { typedef _LIBCPP_NODEBUG __make_unsigned(_Tp) type; };
+#else
 typedef
     __type_list<unsigned char,
     __type_list<unsigned short,
@@ -68,6 +71,7 @@
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
diff --git a/libcxx/include/__type_traits/remove_all_extents.h b/libcxx/include/__type_traits/remove_all_extents.h
--- a/libcxx/include/__type_traits/remove_all_extents.h
+++ b/libcxx/include/__type_traits/remove_all_extents.h
@@ -18,12 +18,16 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_all_extents)
+template <class _Tp> struct remove_all_extents { typedef _LIBCPP_NODEBUG __remove_all_extents(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents
     {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[]>
     {typedef typename remove_all_extents<_Tp>::type type;};
 template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_all_extents<_Tp[_Np]>
     {typedef typename remove_all_extents<_Tp>::type type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
diff --git a/libcxx/include/__type_traits/remove_const.h b/libcxx/include/__type_traits/remove_const.h
--- a/libcxx/include/__type_traits/remove_const.h
+++ b/libcxx/include/__type_traits/remove_const.h
@@ -17,8 +17,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_const)
+template <class _Tp> struct remove_const { typedef _LIBCPP_NODEBUG __remove_const(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const            {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
+#endif
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 #endif
diff --git a/libcxx/include/__type_traits/remove_cv.h b/libcxx/include/__type_traits/remove_cv.h
--- a/libcxx/include/__type_traits/remove_cv.h
+++ b/libcxx/include/__type_traits/remove_cv.h
@@ -19,8 +19,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_cv)
+template <class _Tp> struct remove_cv { typedef _LIBCPP_NODEBUG __remove_cv(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
 {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
+#endif
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
 #endif
diff --git a/libcxx/include/__type_traits/remove_cvref.h b/libcxx/include/__type_traits/remove_cvref.h
--- a/libcxx/include/__type_traits/remove_cvref.h
+++ b/libcxx/include/__type_traits/remove_cvref.h
@@ -20,12 +20,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+
+#if __has_builtin(__remove_cvref)
+template <class _Tp> using __uncvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
+
+#if _LIBCPP_STD_VER > 17
+template <class _Tp> struct remove_cvref { using type _LIBCPP_NODEBUG = __remove_cvref(_Tp); };
+
+template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
+#endif
+#else
 template <class _Tp>
 using __uncvref_t _LIBCPP_NODEBUG = typename remove_cv<typename remove_reference<_Tp>::type>::type;
 
-template <class _Tp, class _Up>
-struct __is_same_uncvref : _IsSame<__uncvref_t<_Tp>, __uncvref_t<_Up> > {};
-
 #if _LIBCPP_STD_VER > 17
 // remove_cvref - same as __uncvref
 template <class _Tp>
@@ -35,6 +42,10 @@
 
 template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
 #endif
+#endif
+
+template <class _Tp, class _Up>
+struct __is_same_uncvref : _IsSame<__uncvref_t<_Tp>, __uncvref_t<_Up> > {};
 
 _LIBCPP_END_NAMESPACE_STD
 
diff --git a/libcxx/include/__type_traits/remove_extent.h b/libcxx/include/__type_traits/remove_extent.h
--- a/libcxx/include/__type_traits/remove_extent.h
+++ b/libcxx/include/__type_traits/remove_extent.h
@@ -18,12 +18,16 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_extent)
+template <class _Tp> struct remove_extent { typedef _LIBCPP_NODEBUG __remove_extent(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent
     {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[]>
     {typedef _Tp type;};
 template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS remove_extent<_Tp[_Np]>
     {typedef _Tp type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
diff --git a/libcxx/include/__type_traits/remove_pointer.h b/libcxx/include/__type_traits/remove_pointer.h
--- a/libcxx/include/__type_traits/remove_pointer.h
+++ b/libcxx/include/__type_traits/remove_pointer.h
@@ -17,11 +17,15 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_pointer)
+template <class _Tp> struct remove_pointer { typedef _LIBCPP_NODEBUG __remove_pointer(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer                      {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp*>                {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const>          {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* volatile>       {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_pointer<_Tp* const volatile> {typedef _LIBCPP_NODEBUG _Tp type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
diff --git a/libcxx/include/__type_traits/remove_reference.h b/libcxx/include/__type_traits/remove_reference.h
--- a/libcxx/include/__type_traits/remove_reference.h
+++ b/libcxx/include/__type_traits/remove_reference.h
@@ -18,9 +18,13 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_reference)
+template <class _Tp> struct remove_reference { typedef _LIBCPP_NODEBUG __remove_reference(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference        {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&>  {typedef _LIBCPP_NODEBUG _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG _Tp type;};
+#endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
diff --git a/libcxx/include/__type_traits/remove_volatile.h b/libcxx/include/__type_traits/remove_volatile.h
--- a/libcxx/include/__type_traits/remove_volatile.h
+++ b/libcxx/include/__type_traits/remove_volatile.h
@@ -17,8 +17,12 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_volatile)
+template <class _Tp> struct remove_volatile { typedef _LIBCPP_NODEBUG __remove_volatile(_Tp) type; };
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile               {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
+#endif
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif
diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits
--- a/libcxx/include/type_traits
+++ b/libcxx/include/type_traits
@@ -679,7 +679,7 @@
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_swappable
     : public conditional<
-        __is_referenceable<_Tp>::value,
+        __referenceable<_Tp>::value,
         is_swappable_with<
             typename add_lvalue_reference<_Tp>::type,
             typename add_lvalue_reference<_Tp>::type>,
@@ -697,7 +697,7 @@
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
     : public conditional<
-        __is_referenceable<_Tp>::value,
+        __referenceable<_Tp>::value,
         is_nothrow_swappable_with<
             typename add_lvalue_reference<_Tp>::type,
             typename add_lvalue_reference<_Tp>::type>,
diff --git a/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp b/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
--- a/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
+++ b/libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp
@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 //
 
-// __is_referenceable<Tp>
+// __referenceable<Tp>
 //
 // [defns.referenceable] defines "a referenceable type" as:
 // An object type, a function type that does not have cv-qualifiers
@@ -21,172 +21,172 @@
 
 struct Foo {};
 
-static_assert((!std::__is_referenceable<void>::value), "");
-static_assert(( std::__is_referenceable<int>::value), "");
-static_assert(( std::__is_referenceable<int[3]>::value), "");
-static_assert(( std::__is_referenceable<int[]>::value), "");
-static_assert(( std::__is_referenceable<int &>::value), "");
-static_assert(( std::__is_referenceable<const int &>::value), "");
-static_assert(( std::__is_referenceable<int *>::value), "");
-static_assert(( std::__is_referenceable<const int *>::value), "");
-static_assert(( std::__is_referenceable<Foo>::value), "");
-static_assert(( std::__is_referenceable<const Foo>::value), "");
-static_assert(( std::__is_referenceable<Foo &>::value), "");
-static_assert(( std::__is_referenceable<const Foo &>::value), "");
+static_assert((!std::__referenceable<void>::value), "");
+static_assert(( std::__referenceable<int>::value), "");
+static_assert(( std::__referenceable<int[3]>::value), "");
+static_assert(( std::__referenceable<int[]>::value), "");
+static_assert(( std::__referenceable<int &>::value), "");
+static_assert(( std::__referenceable<const int &>::value), "");
+static_assert(( std::__referenceable<int *>::value), "");
+static_assert(( std::__referenceable<const int *>::value), "");
+static_assert(( std::__referenceable<Foo>::value), "");
+static_assert(( std::__referenceable<const Foo>::value), "");
+static_assert(( std::__referenceable<Foo &>::value), "");
+static_assert(( std::__referenceable<const Foo &>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<Foo &&>::value), "");
-static_assert(( std::__is_referenceable<const Foo &&>::value), "");
+static_assert(( std::__referenceable<Foo &&>::value), "");
+static_assert(( std::__referenceable<const Foo &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<int   __attribute__((__vector_size__( 8)))>::value), "");
-static_assert(( std::__is_referenceable<const int   __attribute__((__vector_size__( 8)))>::value), "");
-static_assert(( std::__is_referenceable<float __attribute__((__vector_size__(16)))>::value), "");
-static_assert(( std::__is_referenceable<const float __attribute__((__vector_size__(16)))>::value), "");
+static_assert(( std::__referenceable<int   __attribute__((__vector_size__( 8)))>::value), "");
+static_assert(( std::__referenceable<const int   __attribute__((__vector_size__( 8)))>::value), "");
+static_assert(( std::__referenceable<float __attribute__((__vector_size__(16)))>::value), "");
+static_assert(( std::__referenceable<const float __attribute__((__vector_size__(16)))>::value), "");
 
 // Functions without cv-qualifiers are referenceable
-static_assert(( std::__is_referenceable<void ()>::value), "");
+static_assert(( std::__referenceable<void ()>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void () const>::value), "");
-static_assert((!std::__is_referenceable<void () &>::value), "");
-static_assert((!std::__is_referenceable<void () const &>::value), "");
-static_assert((!std::__is_referenceable<void () &&>::value), "");
-static_assert((!std::__is_referenceable<void () const &&>::value), "");
+static_assert((!std::__referenceable<void () const>::value), "");
+static_assert((!std::__referenceable<void () &>::value), "");
+static_assert((!std::__referenceable<void () const &>::value), "");
+static_assert((!std::__referenceable<void () &&>::value), "");
+static_assert((!std::__referenceable<void () const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int)>::value), "");
+static_assert(( std::__referenceable<void (int)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int) const>::value), "");
-static_assert((!std::__is_referenceable<void (int) &>::value), "");
-static_assert((!std::__is_referenceable<void (int) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int) const &&>::value), "");
+static_assert((!std::__referenceable<void (int) const>::value), "");
+static_assert((!std::__referenceable<void (int) &>::value), "");
+static_assert((!std::__referenceable<void (int) const &>::value), "");
+static_assert((!std::__referenceable<void (int) &&>::value), "");
+static_assert((!std::__referenceable<void (int) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float)>::value), "");
+static_assert(( std::__referenceable<void (int, float)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int, float) const>::value), "");
-static_assert((!std::__is_referenceable<void (int, float) &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int, float) const &&>::value), "");
+static_assert((!std::__referenceable<void (int, float) const>::value), "");
+static_assert((!std::__referenceable<void (int, float) &>::value), "");
+static_assert((!std::__referenceable<void (int, float) const &>::value), "");
+static_assert((!std::__referenceable<void (int, float) &&>::value), "");
+static_assert((!std::__referenceable<void (int, float) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, Foo &)>::value), "");
+static_assert(( std::__referenceable<void (int, float, Foo &)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int, float, Foo &) const>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &) &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &) const &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &) const>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &) &>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &) const &>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &) &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (...)>::value), "");
+static_assert(( std::__referenceable<void (...)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (...) const>::value), "");
-static_assert((!std::__is_referenceable<void (...) &>::value), "");
-static_assert((!std::__is_referenceable<void (...) const &>::value), "");
-static_assert((!std::__is_referenceable<void (...) &&>::value), "");
-static_assert((!std::__is_referenceable<void (...) const &&>::value), "");
+static_assert((!std::__referenceable<void (...) const>::value), "");
+static_assert((!std::__referenceable<void (...) &>::value), "");
+static_assert((!std::__referenceable<void (...) const &>::value), "");
+static_assert((!std::__referenceable<void (...) &&>::value), "");
+static_assert((!std::__referenceable<void (...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, ...)>::value), "");
+static_assert(( std::__referenceable<void (int, ...)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int, ...) const>::value), "");
-static_assert((!std::__is_referenceable<void (int, ...) &>::value), "");
-static_assert((!std::__is_referenceable<void (int, ...) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int, ...) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int, ...) const &&>::value), "");
+static_assert((!std::__referenceable<void (int, ...) const>::value), "");
+static_assert((!std::__referenceable<void (int, ...) &>::value), "");
+static_assert((!std::__referenceable<void (int, ...) const &>::value), "");
+static_assert((!std::__referenceable<void (int, ...) &&>::value), "");
+static_assert((!std::__referenceable<void (int, ...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, ...)>::value), "");
+static_assert(( std::__referenceable<void (int, float, ...)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int, float, ...) const>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, ...) &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, ...) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, ...) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, ...) const &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, ...) const>::value), "");
+static_assert((!std::__referenceable<void (int, float, ...) &>::value), "");
+static_assert((!std::__referenceable<void (int, float, ...) const &>::value), "");
+static_assert((!std::__referenceable<void (int, float, ...) &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, ...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, Foo &, ...)>::value), "");
+static_assert(( std::__referenceable<void (int, float, Foo &, ...)>::value), "");
 #if TEST_STD_VER >= 11
-static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const &>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) &&>::value), "");
-static_assert((!std::__is_referenceable<void (int, float, Foo &, ...) const &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &, ...) const>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &, ...) &>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &, ...) const &>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &, ...) &&>::value), "");
+static_assert((!std::__referenceable<void (int, float, Foo &, ...) const &&>::value), "");
 #endif
 
 // member functions with or without cv-qualifiers are referenceable
-static_assert(( std::__is_referenceable<void (Foo::*)()>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)() const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)()>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)() const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)() &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)() const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)() &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)() const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)() &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)() const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)() &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)() const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(...)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(...) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(...) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(...) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(...) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(...) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, ...) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, ...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, ...) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, ...) const &&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...)>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...)>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...) const>::value), "");
 #if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) &&>::value), "");
-static_assert(( std::__is_referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...) &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...) const &>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...) &&>::value), "");
+static_assert(( std::__referenceable<void (Foo::*)(int, float, Foo &, ...) const &&>::value), "");
 #endif
 
 int main(int, char**) {