[libc++] Temporarily not use compiler intrinsics for some type traits in Objective-C++ mode.

[var-const]

Summary

Currently, there are bugs in Clang's intrinsics for type traits when
handling Objective-C++ id (e.g. in add_pointer). As a temporary
workaround, don't use these intrinsics in the Objective-C++ mode.

[var-const]

@tstellar Would it be possible to merge this patch directly into the release/16.x branch? It's an important fix (compiler bug workaround) for the Objective-C++ mode that is affecting the LLVM 16 release. Unfortunately, the patch doesn't apply cleanly to main, and we also hope that the compiler bug would be fixed before the next release so that this workaround will become unnecessary. If merging to the release branch is not okay, I'm not sure what the correct workflow would be. I can make the fix on the main branch, but it won't cleanly cherry-pick into the release, so I'm not sure if the GitHub automation can handle that.

[philnik]

libcxx/include/__config

1262

Can you file a bug against Clang and link it here? This makes it easier to check whether the bug is fixed.

1264–1266

We normally disable stuff the other way around. Is there a reason to do it differently here?

[var-const]

libcxx/include/__config

1262

That's a good point, will do.

1264–1266

I used _LIBCPP_USING_DEV_RANDOM as the model, and I saw it more like "Are we allowed to use this feature?" rather than "Should we suppress the use of this feature?" I feel that our type traits are undertested and there might be more issues with the compiler intrinsics, so the default should be to use the old implementation (which, while still undertested in our code, is known to work in the wild with no major issues).

[ldionne]

This is superseded by D145186, I'd suggest closing this. We'll cherry-pick onto release/16.x via the usual means

[var-const]

Abandoning in favor of https://reviews.llvm.org/D145186.

libcxx/include/__config

 #if _LIBCPP_STD_VER >= 17
 #    define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName)                                                                \
       template <class ..._Tag>                                                                                         \
       _ClassName(typename _Tag::__allow_ctad...) -> _ClassName<_Tag...>
 #else
 #  define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
 #endif
 
+// TODO(varconst): currently, there are bugs in Clang's intrinsics when handling Objective-C++ `id`, so don't use
+// compiler intrinsics in the Objective-C++ mode.
+#ifndef __OBJC__
+#define _LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS
+#endif
+
 #endif // __cplusplus
 
 #endif // _LIBCPP___CONFIG

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
 
-#if __has_builtin(__add_lvalue_reference)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_lvalue_reference)
 
 template <class _Tp>
 using __add_lvalue_reference_t = __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>
 using __add_lvalue_reference_t = typename __add_lvalue_reference_impl<_Tp>::type;
 
-#endif // __has_builtin(__add_lvalue_reference)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_lvalue_reference)
 
 template <class _Tp>
 struct add_lvalue_reference {
   using type _LIBCPP_NODEBUG = __add_lvalue_reference_t<_Tp>;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = __add_lvalue_reference_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_pointer)
 
 template <class _Tp>
 using __add_pointer_t = __add_pointer(_Tp);
 
 #else
 template <class _Tp,
           bool = __libcpp_is_referenceable<_Tp>::value || is_void<_Tp>::value>
 struct __add_pointer_impl {
   typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp>* type;
 };
 template <class _Tp> struct __add_pointer_impl<_Tp, false>
     {typedef _LIBCPP_NODEBUG _Tp type;};
 
 template <class _Tp>
 using __add_pointer_t = typename __add_pointer_impl<_Tp>::type;
 
-#endif // __has_builtin(__add_pointer)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_pointer)
 
 template <class _Tp>
 struct add_pointer {
   using type _LIBCPP_NODEBUG = __add_pointer_t<_Tp>;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_pointer_t = __add_pointer_t<_Tp>;
 #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
 
-#if __has_builtin(__add_rvalue_reference)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_rvalue_reference)
 
 template <class _Tp>
 using __add_rvalue_reference_t = __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>
 using __add_rvalue_reference_t = typename __add_rvalue_reference_impl<_Tp>::type;
 
-#endif // __has_builtin(__add_rvalue_reference)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__add_rvalue_reference)
 
 template <class _Tp>
 struct add_rvalue_reference {
   using type = __add_rvalue_reference_t<_Tp>;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp>
 using add_rvalue_reference_t = __add_rvalue_reference_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__decay)
 template <class _Tp>
 struct decay {
   using type _LIBCPP_NODEBUG = __decay(_Tp);
 };
 #else
 template <class _Up, bool>
 struct __decay {
     typedef _LIBCPP_NODEBUG __remove_cv_t<_Up> type;

 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS decay
 {
 private:
     typedef _LIBCPP_NODEBUG __libcpp_remove_reference_t<_Tp> _Up;
 public:
   typedef _LIBCPP_NODEBUG typename __decay<_Up, __libcpp_is_referenceable<_Up>::value>::type type;
 };
-#endif // __has_builtin(__decay)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __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
 
-#if __has_builtin(__is_referenceable)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __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 __libcpp_is_referenceable
     : integral_constant<bool, _IsNotSame<decltype(__libcpp_is_referenceable_impl::__test<_Tp>(0)), false_type>::value> {
 };
-#endif // __has_builtin(__is_referenceable)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__is_referenceable)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_REFERENCEABLE_H

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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__make_signed)
 
 template <class _Tp>
 using __make_signed_t = __make_signed(_Tp);
 
 #else
 typedef
     __type_list<signed char,
     __type_list<signed short,

 #  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
 
 template <class _Tp>
 using __make_signed_t = typename __apply_cv<_Tp, typename __make_signed<__remove_cv_t<_Tp> >::type>::type;
 
-#endif // __has_builtin(__make_signed)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__make_signed)
 
 template <class _Tp>
 struct make_signed {
   using type _LIBCPP_NODEBUG = __make_signed_t<_Tp>;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_signed_t = __make_signed_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__make_unsigned)
 
 template <class _Tp>
 using __make_unsigned_t = __make_unsigned(_Tp);
 
 #else
 typedef
     __type_list<unsigned char,
     __type_list<unsigned short,

 #  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
 
 template <class _Tp>
 using __make_unsigned_t = typename __apply_cv<_Tp, typename __make_unsigned<__remove_cv_t<_Tp> >::type>::type;
 
-#endif // __has_builtin(__make_unsigned)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__make_unsigned)
 
 template <class _Tp>
 struct make_unsigned {
   using type _LIBCPP_NODEBUG = __make_unsigned_t<_Tp>;
 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using make_unsigned_t = __make_unsigned_t<_Tp>;

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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_all_extents)
 template <class _Tp>
 struct remove_all_extents {
   using type _LIBCPP_NODEBUG = __remove_all_extents(_Tp);
 };
 
 template <class _Tp>
 using __remove_all_extents_t = __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;};
 
 template <class _Tp>
 using __remove_all_extents_t = typename remove_all_extents<_Tp>::type;
-#endif // __has_builtin(__remove_all_extents)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_all_extents)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_all_extents_t = __remove_all_extents_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_const)
 template <class _Tp>
 struct remove_const {
   using type _LIBCPP_NODEBUG = __remove_const(_Tp);
 };
 
 template <class _Tp>
 using __remove_const_t = __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;};
 
 template <class _Tp>
 using __remove_const_t = typename remove_const<_Tp>::type;
-#endif // __has_builtin(__remove_const)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_const)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = __remove_const_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_cv)
 template <class _Tp>
 struct remove_cv {
   using type _LIBCPP_NODEBUG = __remove_cv(_Tp);
 };
 
 template <class _Tp>
 using __remove_cv_t = __remove_cv(_Tp);
 #else
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
 {typedef __remove_volatile_t<__remove_const_t<_Tp> > type;};
 
 template <class _Tp>
 using __remove_cv_t = __remove_volatile_t<__remove_const_t<_Tp> >;
-#endif // __has_builtin(__remove_cv)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_cv)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = __remove_cv_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_cvref)
 template <class _Tp>
 using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cvref(_Tp);
 #else
 template <class _Tp>
 using __remove_cvref_t _LIBCPP_NODEBUG = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >;
-#endif // __has_builtin(__remove_cvref)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_cvref)
 
 template <class _Tp, class _Up>
 struct __is_same_uncvref : _IsSame<__remove_cvref_t<_Tp>, __remove_cvref_t<_Up> > {};
 
 #if _LIBCPP_STD_VER > 17
 template <class _Tp>
 struct remove_cvref {
     using type _LIBCPP_NODEBUG = __remove_cvref_t<_Tp>;
 };
 
 template <class _Tp> using remove_cvref_t = __remove_cvref_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_extent)
 template <class _Tp>
 struct remove_extent {
   using type _LIBCPP_NODEBUG = __remove_extent(_Tp);
 };
 
 template <class _Tp>
 using __remove_extent_t = __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;};
 
 template <class _Tp>
 using __remove_extent_t = typename remove_extent<_Tp>::type;
-#endif // __has_builtin(__remove_extent)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_extent)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_extent_t = __remove_extent_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_pointer)
 template <class _Tp>
 struct remove_pointer {
   using type _LIBCPP_NODEBUG = __remove_pointer(_Tp);
 };
 
 template <class _Tp>
 using __remove_pointer_t = __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;};
 
 template <class _Tp>
 using __remove_pointer_t = typename remove_pointer<_Tp>::type;
-#endif // __has_builtin(__remove_pointer)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_pointer)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_pointer_t = __remove_pointer_t<_Tp>;
 #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_t)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_reference_t)
 template <class _Tp>
 struct remove_reference {
   using type _LIBCPP_NODEBUG = __remove_reference_t(_Tp);
 };
 
 template <class _Tp>
 using __libcpp_remove_reference_t = __remove_reference_t(_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;};
 
 template <class _Tp>
 using __libcpp_remove_reference_t = typename remove_reference<_Tp>::type;
-#endif // __has_builtin(__remove_reference_t)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_reference_t)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_reference_t = __libcpp_remove_reference_t<_Tp>;
 #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)
+#if defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_volatile)
 template <class _Tp>
 struct remove_volatile {
   using type _LIBCPP_NODEBUG = __remove_volatile(_Tp);
 };
 
 template <class _Tp>
 using __remove_volatile_t = __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;};
 
 template <class _Tp>
 using __remove_volatile_t = typename remove_volatile<_Tp>::type;
-#endif // __has_builtin(__remove_volatile)
+#endif // defined(_LIBCPP_USING_TYPE_TRAITS_COMPILER_INTRINSICS) && __has_builtin(__remove_volatile)
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = __remove_volatile_t<_Tp>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_REMOVE_VOLATILE_H