[libcxx][NFC] utilises compiler builtins for unary transform type-traits

[cjdb]

Summary

Depends on D116203

[philnik]

Which compiler supports these builtins? Neither GCC nor clang accept __add_lvalue_reference or __add_pointer: https://godbolt.org/z/nvxqWTGY1

[cjdb]

In D131732#3717669, @philnik wrote:

Which compiler supports these builtins? Neither GCC nor clang accept __add_lvalue_reference or __add_pointer: https://godbolt.org/z/nvxqWTGY1

See D116203.

[philnik]

In D131732#3717939, @cjdb wrote:

In D131732#3717669, @philnik wrote:

Which compiler supports these builtins? Neither GCC nor clang accept __add_lvalue_reference or __add_pointer: https://godbolt.org/z/nvxqWTGY1

See D116203.

Could you rebase on top of D116203 to run the clang patch with this patch together in the CI? I think it would be good to land these two patches at the same time.
Do you have any benchmarks to show how much of a difference it makes?

libcxx/include/__type_traits/add_lvalue_reference.h

21–30

For all of the changes: Please clang-format them and use using instead of typedef.

libcxx/include/__type_traits/decay.h

64

Please also add a comment to other longer preprocessor conditions.

libcxx/include/__type_traits/is_referenceable.h

23

I think a better name would be __libcpp_is_referenceable. __referenceable sounds a lot like a concept, not a type trait.

libcxx/include/__type_traits/remove_cvref.h

30

This is just a duplicate of line 43. Could you move them out of the #if __has_builtin() instead?

[cjdb]

responds to feedback, updates commit message so it pulls in D116203 when CI is on

[cjdb]

made a change to a diagnostic in D116203, so rebasing here

[philnik]

LGTM. You can ignore the test timeout.

[cjdb]

rebases to activate CI

[rupprecht]

The commit says NFC, but we found this to be an observable behavior change with __restrict now being dropped as part of std::decay: https://godbolt.org/z/zqvW478jq. It impacted us via use of std::make_pair which decays the types, and we had a static_assert checking that the type passed in had __restrict on it.

We have a workaround (just don't use std::make_pair), but I figured I should mention this since the commit is labelled NFC, so any observable change is a surprise.

IIUC, because __restrict is non-standard C++, it's implementation defined whether std::decay wants to modify it or not. Therefore, both before and after are "correct", and code should not rely on which option we choose.

[cjdb]

In D131732#3750935, @rupprecht wrote:

The commit says NFC, but we found this to be an observable behavior change with __restrict now being dropped as part of std::decay: https://godbolt.org/z/zqvW478jq. It impacted us via use of std::make_pair which decays the types, and we had a static_assert checking that the type passed in had __restrict on it.

We have a workaround (just don't use std::make_pair), but I figured I should mention this since the commit is labelled NFC, so any observable change is a surprise.

IIUC, because __restrict is non-standard C++, it's implementation defined whether std::decay wants to modify it or not. Therefore, both before and after are "correct", and code should not rely on which option we choose.

Thanks for flagging this.

It was a deliberate choice to have __decay drop all CVR qualifiers in D116203, with the rationale being that if C++ supported restrict, it would probably be affected by std::decay. The libc++ change was supposed to be NFC, but I'd forgotten about the strictness of __decay by the time I'd gotten around to changing libc++ code.

I see two paths forward:

1. Wait to see if any libc++ maintainers have opinions regarding __restrict. I don't think that they have up until now, since their CI would've caught it otherwise; though they might want to retroactively have opinions now that we know people have been negatively impacted by this.
2. Immediately patch Clang so that __decay doesn't impact __restrict, since people have been negatively impacted by this change.

[philnik]

In D131732#3751895, @cjdb wrote:

In D131732#3750935, @rupprecht wrote:

The commit says NFC, but we found this to be an observable behavior change with __restrict now being dropped as part of std::decay: https://godbolt.org/z/zqvW478jq. It impacted us via use of std::make_pair which decays the types, and we had a static_assert checking that the type passed in had __restrict on it.

We have a workaround (just don't use std::make_pair), but I figured I should mention this since the commit is labelled NFC, so any observable change is a surprise.

IIUC, because __restrict is non-standard C++, it's implementation defined whether std::decay wants to modify it or not. Therefore, both before and after are "correct", and code should not rely on which option we choose.

Thanks for flagging this.

It was a deliberate choice to have __decay drop all CVR qualifiers in D116203, with the rationale being that if C++ supported restrict, it would probably be affected by std::decay. The libc++ change was supposed to be NFC, but I'd forgotten about the strictness of __decay by the time I'd gotten around to changing libc++ code.

I see two paths forward:

1. Wait to see if any libc++ maintainers have opinions regarding __restrict. I don't think that they have up until now, since their CI would've caught it otherwise; though they might want to retroactively have opinions now that we know people have been negatively impacted by this.
2. Immediately patch Clang so that __decay doesn't impact __restrict, since people have been negatively impacted by this change.

#include <type_traits>

int main() {
  int* __restrict const volatile a = nullptr;
  auto v = a;
  static_assert(std::is_same_v<decltype(v), int*>);
}

Clang says that __restrict is dropped here, so I think it should also be dropped when using std::decay. @cjdb could you make a follow-up to also fix this for GCC and add tests?

[cjdb]

In D131732#3751943, @philnik wrote:

In D131732#3751895, @cjdb wrote:

In D131732#3750935, @rupprecht wrote:

The commit says NFC, but we found this to be an observable behavior change with __restrict now being dropped as part of std::decay: https://godbolt.org/z/zqvW478jq. It impacted us via use of std::make_pair which decays the types, and we had a static_assert checking that the type passed in had __restrict on it.

We have a workaround (just don't use std::make_pair), but I figured I should mention this since the commit is labelled NFC, so any observable change is a surprise.

IIUC, because __restrict is non-standard C++, it's implementation defined whether std::decay wants to modify it or not. Therefore, both before and after are "correct", and code should not rely on which option we choose.

Thanks for flagging this.

It was a deliberate choice to have __decay drop all CVR qualifiers in D116203, with the rationale being that if C++ supported restrict, it would probably be affected by std::decay. The libc++ change was supposed to be NFC, but I'd forgotten about the strictness of __decay by the time I'd gotten around to changing libc++ code.

I see two paths forward:

1. Wait to see if any libc++ maintainers have opinions regarding __restrict. I don't think that they have up until now, since their CI would've caught it otherwise; though they might want to retroactively have opinions now that we know people have been negatively impacted by this.
2. Immediately patch Clang so that __decay doesn't impact __restrict, since people have been negatively impacted by this change.

#include <type_traits>

int main() {
  int* __restrict const volatile a = nullptr;
  auto v = a;
  static_assert(std::is_same_v<decltype(v), int*>);
}

Clang says that __restrict is dropped here, so I think it should also be dropped when using std::decay. @cjdb could you make a follow-up to also fix this for GCC and add tests?

I can add tests for libc++, but I'm not familiar with the GCC codebase. @jwakely, do you have any opinions on this particular change, and if you're of a similar mind, would you mind helping out on the libstdc++ side of things please?

[philnik]

@cjdb I meant that the other decay implementation should be fixed to be the same as the builtin. IOW the one that GCC uses, since it doesn't have the builtin. Sorry for the confusion.

[cjdb]

In D131732#3752063, @philnik wrote:

@cjdb I meant that the other decay implementation should be fixed to be the same as the builtin. IOW the one that GCC uses, since it doesn't have the builtin. Sorry for the confusion.

Thanks for clarifying. After double checking the Clang test, I see that __decay strips all qualifiers: not just __restrict. For example, int* _Nonnull will become int*. There are a lots of these, and I'm not sure how we'd want to handle this without ironically impacting build times.

libcxx/include/__type_traits/add_lvalue_reference.h

 #include <__type_traits/is_referenceable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _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 {
+  using type _LIBCPP_NODEBUG = __add_lvalue_reference(_Tp);
+};
+#else
+template <class _Tp, bool = __libcpp_is_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 // __has_builtin(__add_lvalue_reference)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_ADD_LVALUE_REFERENCE_H

libcxx/include/__type_traits/add_pointer.h

 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__add_pointer)
+template <class _Tp>
+struct add_pointer {
+  using type _LIBCPP_NODEBUG = __add_pointer(_Tp);
+};
+#else
 template <class _Tp,
-        bool = __is_referenceable<_Tp>::value ||
-                _IsSame<typename remove_cv<_Tp>::type, void>::value>
-struct __add_pointer_impl
-    {typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type;};
+          bool = __libcpp_is_referenceable<_Tp>::value || _IsSame<typename remove_cv<_Tp>::type, void>::value>
+struct __add_pointer_impl {
+  typedef _LIBCPP_NODEBUG typename remove_reference<_Tp>::type* type;
+};
 template <class _Tp> struct __add_pointer_impl<_Tp, false>
     {typedef _LIBCPP_NODEBUG _Tp type;};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_pointer
     {typedef _LIBCPP_NODEBUG typename __add_pointer_impl<_Tp>::type type;};
+#endif // __has_builtin(__add_pointer)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_pointer_t = typename add_pointer<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_ADD_POINTER_H

libcxx/include/__type_traits/add_rvalue_reference.h

 #include <__type_traits/is_referenceable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _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 {
+  using type _LIBCPP_NODEBUG = __add_rvalue_reference(_Tp);
+};
+#else
+template <class _Tp, bool = __libcpp_is_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 // __has_builtin(__add_rvalue_reference)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_ADD_RVALUE_REFERENCE_H

libcxx/include/__type_traits/decay.h

 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__decay)
+template <class _Tp>
+struct decay {
+  using type _LIBCPP_NODEBUG = __decay(_Tp);
+};
+#else
 template <class _Up, bool>
 struct __decay {
     typedef _LIBCPP_NODEBUG typename remove_cv<_Up>::type type;
 };
 
 template <class _Up>
 struct __decay<_Up, true> {
 public:

 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS decay
 {
 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, __libcpp_is_referenceable<_Up>::value>::type type;
 };
+#endif // __has_builtin(__decay)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using decay_t = typename decay<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_DECAY_H

libcxx/include/__type_traits/is_referenceable.h

 #include <__type_traits/is_same.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-struct __is_referenceable_impl {
-    template <class _Tp> static _Tp& __test(int);
-    template <class _Tp> static false_type __test(...);
+#if __has_builtin(__is_referenceable)
+template <class _Tp>
+struct __libcpp_is_referenceable : integral_constant<bool, __is_referenceable(_Tp)> {};
+#else
+struct __libcpp_is_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 __libcpp_is_referenceable
+    : integral_constant<bool, _IsNotSame<decltype(__libcpp_is_referenceable_impl::__test<_Tp>(0)), false_type>::value> {
+};
+#endif // __has_builtin(__is_referenceable)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_REFERENCEABLE_H

libcxx/include/__type_traits/is_swappable.h

 struct _LIBCPP_TEMPLATE_VIS is_swappable_with
     : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
 {
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_swappable
     : public conditional<
-        __is_referenceable<_Tp>::value,
+        __libcpp_is_referenceable<_Tp>::value,
         is_swappable_with<
             typename add_lvalue_reference<_Tp>::type,
             typename add_lvalue_reference<_Tp>::type>,
         false_type
     >::type
 {
 };
 
 template <class _Tp, class _Up>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable_with
     : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
 {
 };
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_swappable
     : public conditional<
-        __is_referenceable<_Tp>::value,
+        __libcpp_is_referenceable<_Tp>::value,
         is_nothrow_swappable_with<
             typename add_lvalue_reference<_Tp>::type,
             typename add_lvalue_reference<_Tp>::type>,
         false_type
     >::type
 {
 };
 

libcxx/include/__type_traits/make_signed.h

 #include <__type_traits/type_list.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__make_signed)
+template <class _Tp>
+struct make_signed {
+  using type _LIBCPP_NODEBUG = __make_signed(_Tp);
+};
+#else
 typedef
     __type_list<signed char,
     __type_list<signed short,
     __type_list<signed int,
     __type_list<signed long,
     __type_list<signed long long,
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     __type_list<__int128_t,
-#endif
+#  endif
     __nat
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     >
-#endif
+#  endif
     > > > > > __signed_types;
 
 template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
 struct __make_signed {};
 
 template <class _Tp>
 struct __make_signed<_Tp, true>
 {
     typedef typename __find_first<__signed_types, sizeof(_Tp)>::type type;
 };
 
 template <> struct __make_signed<bool,               true> {};
 template <> struct __make_signed<  signed short,     true> {typedef short     type;};
 template <> struct __make_signed<unsigned short,     true> {typedef short     type;};
 template <> struct __make_signed<  signed int,       true> {typedef int       type;};
 template <> struct __make_signed<unsigned int,       true> {typedef int       type;};
 template <> struct __make_signed<  signed long,      true> {typedef long      type;};
 template <> struct __make_signed<unsigned long,      true> {typedef long      type;};
 template <> struct __make_signed<  signed long long, true> {typedef long long type;};
 template <> struct __make_signed<unsigned long long, true> {typedef long long type;};
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
 template <> struct __make_signed<__int128_t,         true> {typedef __int128_t type;};
 template <> struct __make_signed<__uint128_t,        true> {typedef __int128_t type;};
-#endif
+#  endif
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS make_signed
 {
     typedef typename __apply_cv<_Tp, typename __make_signed<typename remove_cv<_Tp>::type>::type>::type type;
 };
+#endif // __has_builtin(__make_signed)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_signed_t = typename make_signed<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_MAKE_SIGNED_H

libcxx/include/__type_traits/make_unsigned.h

 #include <__type_traits/type_list.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__make_unsigned)
+template <class _Tp>
+struct make_unsigned {
+  using type _LIBCPP_NODEBUG = __make_unsigned(_Tp);
+};
+#else
 typedef
     __type_list<unsigned char,
     __type_list<unsigned short,
     __type_list<unsigned int,
     __type_list<unsigned long,
     __type_list<unsigned long long,
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     __type_list<__uint128_t,
-#endif
+#  endif
     __nat
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
     >
-#endif
+#  endif
     > > > > > __unsigned_types;
 
 template <class _Tp, bool = is_integral<_Tp>::value || is_enum<_Tp>::value>
 struct __make_unsigned {};
 
 template <class _Tp>
 struct __make_unsigned<_Tp, true>
 {
     typedef typename __find_first<__unsigned_types, sizeof(_Tp)>::type type;
 };
 
 template <> struct __make_unsigned<bool,               true> {};
 template <> struct __make_unsigned<  signed short,     true> {typedef unsigned short     type;};
 template <> struct __make_unsigned<unsigned short,     true> {typedef unsigned short     type;};
 template <> struct __make_unsigned<  signed int,       true> {typedef unsigned int       type;};
 template <> struct __make_unsigned<unsigned int,       true> {typedef unsigned int       type;};
 template <> struct __make_unsigned<  signed long,      true> {typedef unsigned long      type;};
 template <> struct __make_unsigned<unsigned long,      true> {typedef unsigned long      type;};
 template <> struct __make_unsigned<  signed long long, true> {typedef unsigned long long type;};
 template <> struct __make_unsigned<unsigned long long, true> {typedef unsigned long long type;};
-#ifndef _LIBCPP_HAS_NO_INT128
+#  ifndef _LIBCPP_HAS_NO_INT128
 template <> struct __make_unsigned<__int128_t,         true> {typedef __uint128_t        type;};
 template <> struct __make_unsigned<__uint128_t,        true> {typedef __uint128_t        type;};
-#endif
+#  endif
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS make_unsigned
 {
     typedef typename __apply_cv<_Tp, typename __make_unsigned<typename remove_cv<_Tp>::type>::type>::type type;
 };
+#endif // __has_builtin(__make_unsigned)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_unsigned_t = typename make_unsigned<_Tp>::type;
 #endif
 
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr

libcxx/include/__type_traits/remove_all_extents.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_all_extents)
+template <class _Tp>
+struct remove_all_extents {
+  using type _LIBCPP_NODEBUG = __remove_all_extents(_Tp);
+};
+#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 // __has_builtin(__remove_all_extents)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_ALL_EXTENTS_H

libcxx/include/__type_traits/remove_const.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_const)
+template <class _Tp>
+struct remove_const {
+  using type _LIBCPP_NODEBUG = __remove_const(_Tp);
+};
+#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 // __has_builtin(__remove_const)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CONST_H

libcxx/include/__type_traits/remove_cv.h

 #include <__type_traits/remove_volatile.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_cv)
+template <class _Tp>
+struct remove_cv {
+  using type _LIBCPP_NODEBUG = __remove_cv(_Tp);
+};
+#else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
 {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
+#endif // __has_builtin(__remove_cv)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CV_H

libcxx/include/__type_traits/remove_cvref.h

 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_cvref)
+template <class _Tp>
+using __uncvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
+#else
 template <class _Tp>
 using __uncvref_t _LIBCPP_NODEBUG = typename remove_cv<typename remove_reference<_Tp>::type>::type;
+#endif // __has_builtin(__remove_cvref)
 
 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>
 struct remove_cvref {
     using type _LIBCPP_NODEBUG = __uncvref_t<_Tp>;
 };
 
 template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_CVREF_H

libcxx/include/__type_traits/remove_extent.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_extent)
+template <class _Tp>
+struct remove_extent {
+  using type _LIBCPP_NODEBUG = __remove_extent(_Tp);
+};
+#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 // __has_builtin(__remove_extent)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_extent_t = typename remove_extent<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_EXTENT_H

libcxx/include/__type_traits/remove_pointer.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_pointer)
+template <class _Tp>
+struct remove_pointer {
+  using type _LIBCPP_NODEBUG = __remove_pointer(_Tp);
+};
+#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 // __has_builtin(__remove_pointer)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_pointer_t = typename remove_pointer<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_POINTER_H

libcxx/include/__type_traits/remove_reference.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_reference)
+template <class _Tp>
+struct remove_reference {
+  using type _LIBCPP_NODEBUG = __remove_reference(_Tp);
+};
+#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 // __has_builtin(__remove_reference)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_REFERENCE_H

libcxx/include/__type_traits/remove_volatile.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#if __has_builtin(__remove_volatile)
+template <class _Tp>
+struct remove_volatile {
+  using type _LIBCPP_NODEBUG = __remove_volatile(_Tp);
+};
+#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 // __has_builtin(__remove_volatile)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H

libcxx/test/libcxx/utilities/meta/is_referenceable.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 
-// __is_referenceable<Tp>
+// __libcpp_is_referenceable<Tp>
 //
 // [defns.referenceable] defines "a referenceable type" as:
 // An object type, a function type that does not have cv-qualifiers
 //    or a ref-qualifier, or a reference type.
 //
 
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 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), "");
-#if TEST_STD_VER >= 11
-static_assert(( std::__is_referenceable<Foo &&>::value), "");
-static_assert(( std::__is_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::__libcpp_is_referenceable<void>::value), "");
+static_assert((std::__libcpp_is_referenceable<int>::value), "");
+static_assert((std::__libcpp_is_referenceable<int[3]>::value), "");
+static_assert((std::__libcpp_is_referenceable<int[]>::value), "");
+static_assert((std::__libcpp_is_referenceable<int&>::value), "");
+static_assert((std::__libcpp_is_referenceable<const int&>::value), "");
+static_assert((std::__libcpp_is_referenceable<int*>::value), "");
+static_assert((std::__libcpp_is_referenceable<const int*>::value), "");
+static_assert((std::__libcpp_is_referenceable<Foo>::value), "");
+static_assert((std::__libcpp_is_referenceable<const Foo>::value), "");
+static_assert((std::__libcpp_is_referenceable<Foo&>::value), "");
+static_assert((std::__libcpp_is_referenceable<const Foo&>::value), "");
+#if TEST_STD_VER >= 11
+static_assert((std::__libcpp_is_referenceable<Foo&&>::value), "");
+static_assert((std::__libcpp_is_referenceable<const Foo&&>::value), "");
+#endif
+
+static_assert((std::__libcpp_is_referenceable<int __attribute__((__vector_size__(8)))>::value), "");
+static_assert((std::__libcpp_is_referenceable<const int __attribute__((__vector_size__(8)))>::value), "");
+static_assert((std::__libcpp_is_referenceable<float __attribute__((__vector_size__(16)))>::value), "");
+static_assert((std::__libcpp_is_referenceable<const float __attribute__((__vector_size__(16)))>::value), "");
 
 // Functions without cv-qualifiers are referenceable
-static_assert(( std::__is_referenceable<void ()>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void() const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void() &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void() const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void() &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void() const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int, float) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, Foo &)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int, float, Foo&) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(...) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(...) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(...) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(...) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(...) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int, ...) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, ...) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, ...) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, ...) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, ...) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int, float, ...) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, ...) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, ...) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, ...) &&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, ...) const&&>::value), "");
 #endif
 
-static_assert(( std::__is_referenceable<void (int, float, Foo &, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void(int, float, Foo&, ...) const>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&, ...) &>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&, ...) const&>::value), "");
+static_assert((!std::__libcpp_is_referenceable<void(int, float, Foo&, ...) &&>::value), "");
+static_assert((!std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)()>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)() &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)() const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)() &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(...) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(...) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(...) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, ...) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, ...) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, ...) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, ...) &&>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&, ...)>::value), "");
+static_assert((std::__libcpp_is_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::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&, ...) &>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&, ...) const&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&, ...) &&>::value), "");
+static_assert((std::__libcpp_is_referenceable<void (Foo::*)(int, float, Foo&, ...) const&&>::value), "");
 #endif
 
 int main(int, char**) {
   return 0;
 }