[libc++] Simplify type_traits a bit more

[philnik]

Poke CI

[ldionne]

LGTM with rebase and green CI.

[ldionne]

BTW, it's awesome to see these simplifications become possible. This is a payoff for dropping support for unreasonably old compilers.

[philnik]

Rebased

[philnik]

• Fix CI

[philnik]

• Fix GCC

[philnik]

• Work around GCC bug

[philnik]

• Work around implementation divergence

[philnik]

• Next try

[huixie90]

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

26 ↗

(On Diff #452515)

why is this change required?

[philnik]

• Use the old traits implementation for GCC

[philnik]

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

26 ↗

(On Diff #452515)

This isn't actually required. I thought it was implementation divergence, but it's a GCC bug. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611. @CaseyCarter @STL_MSFT you might also want to look into that.

[STL_MSFT]

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

26 ↗

(On Diff #452515)

I'm missing context here - apologies for not being up to speed. MSVC's STL supports MSVC and Clang as first-class citizens (and we use libcxx's test suite with our STL), but we don't attempt to support GCC. Are you requesting any changes to MSVC's compiler or libraries here that we could help with?

[philnik]

libcxx/test/libcxx/ranges/range.adaptors/range.copy.wrap/types.h

26 ↗

(On Diff #452515)

The MSVC compiler has very similar bugs regarding noexcept specifications on defaulted special member functions. https://godbolt.org/z/1z4fb11hr is the full reproducer.

[philnik]

• Fix is_nothrow_move_constructible

[philnik]

• Next try

libcxx/include/__type_traits/alignment_of.h

 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS alignment_of
     : public integral_constant<size_t, _LIBCPP_ALIGNOF(_Tp)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
+inline constexpr size_t alignment_of_v = _LIBCPP_ALIGNOF(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_ALIGNMENT_OF_H

libcxx/include/__type_traits/apply_cv.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_APPLY_CV_H
 #define _LIBCPP___TYPE_TRAITS_APPLY_CV_H
 
 #include <__config>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_const.h>
 #include <__type_traits/is_volatile.h>
 #include <__type_traits/remove_reference.h>
 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__type_traits/decay.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_DECAY_H
 #define _LIBCPP___TYPE_TRAITS_DECAY_H
 
 #include <__config>
 #include <__type_traits/add_pointer.h>
 #include <__type_traits/conditional.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_referenceable.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__type_traits/disjunction.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_DISJUNCTION_H
 #define _LIBCPP___TYPE_TRAITS_DISJUNCTION_H
 
 #include <__config>
-#include <__type_traits/conditional.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__type_traits/has_virtual_destructor.h

 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__has_virtual_destructor)
-
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
     : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
 
-#else
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS has_virtual_destructor
-    : public false_type {};
-
-#endif
-
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool has_virtual_destructor_v = has_virtual_destructor<_Tp>::value;
+inline constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_HAS_VIRTUAL_DESTRUCTOR_H

libcxx/include/__type_traits/is_assignable.h

 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG _Tp type; };
-
-#if __has_builtin(__is_assignable)
-
 template<class _Tp, class _Up>
 struct _LIBCPP_TEMPLATE_VIS is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class _Arg>
 inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Arg);
 #endif
 
-#else // __has_builtin(__is_assignable)
-
-template <class _Tp, class _Arg>
-typename __select_2nd<decltype((declval<_Tp>() = declval<_Arg>())), true_type>::type
-__is_assignable_test(int);
-
-template <class, class>
-false_type __is_assignable_test(...);
-
-
-template <class _Tp, class _Arg, bool = is_void<_Tp>::value || is_void<_Arg>::value>
-struct __is_assignable_imp
-    : public decltype((_VSTD::__is_assignable_test<_Tp, _Arg>(0))) {};
-
-template <class _Tp, class _Arg>
-struct __is_assignable_imp<_Tp, _Arg, true>
-    : public false_type
-{
-};
-
-template <class _Tp, class _Arg>
-struct is_assignable
-    : public __is_assignable_imp<_Tp, _Arg> {};
-
-#if _LIBCPP_STD_VER > 14
-template <class _Tp, class _Arg>
-inline constexpr bool is_assignable_v = is_assignable<_Tp, _Arg>::value;
-#endif
-
-#endif // __has_builtin(__is_assignable)
-
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_ASSIGNABLE_H

libcxx/include/__type_traits/is_class.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_CLASS_H
 #define _LIBCPP___TYPE_TRAITS_IS_CLASS_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_union.h>
-#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_class

libcxx/include/__type_traits/is_constructible.h

 
 template <class _Tp, class ..._Args>
 struct _LIBCPP_TEMPLATE_VIS is_constructible
     : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
 { };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class ..._Args>
-inline constexpr bool is_constructible_v = is_constructible<_Tp, _Args...>::value;
+inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_IS_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_copy_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H
 
 #include <__config>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
-    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
-                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_copy_assignable
+    : public integral_constant<
+          bool,
+          __is_assignable(typename add_lvalue_reference<_Tp>::type,
+                          typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_copy_assignable_v = is_copy_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_copy_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_copy_constructible
-    : public is_constructible<_Tp,
-                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
+    : public integral_constant<
+          bool,
+          __is_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_copy_constructible_v = is_copy_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_default_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_default_constructible
-    : public is_constructible<_Tp>
+    : public integral_constant<bool, __is_constructible(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_default_constructible_v = is_default_constructible<_Tp>::value;
+inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_enum.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_ENUM_H
 #define _LIBCPP___TYPE_TRAITS_IS_ENUM_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum

libcxx/include/__type_traits/is_literal_type.h

 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type
     : public integral_constant<bool, __is_literal_type(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-_LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = is_literal_type<_Tp>::value;
+_LIBCPP_DEPRECATED_IN_CXX17 inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
 #endif // _LIBCPP_STD_VER > 14
 #endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_LITERAL_TYPE

libcxx/include/__type_traits/is_move_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H
 
 #include <__config>
-#include <__type_traits/add_const.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_move_assignable
-    : public is_assignable<typename add_lvalue_reference<_Tp>::type,
-                           typename add_rvalue_reference<_Tp>::type> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_move_assignable
+    : public integral_constant<
+          bool,
+          __is_assignable(typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_move_assignable_v = is_move_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_move_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_move_constructible
-    : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
+    : public integral_constant<bool, __is_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H
 
 #include <__config>
-#include <__type_traits/add_const.h>
 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_nothrow_assignable)
-
 template <class _Tp, class _Arg>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
     : public integral_constant<bool, __is_nothrow_assignable(_Tp, _Arg)> {};
 
-#else
-
-template <bool, class _Tp, class _Arg> struct __libcpp_is_nothrow_assignable;
-
-template <class _Tp, class _Arg>
-struct __libcpp_is_nothrow_assignable<false, _Tp, _Arg>
-    : public false_type
-{
-};
-
-template <class _Tp, class _Arg>
-struct __libcpp_is_nothrow_assignable<true, _Tp, _Arg>
-    : public integral_constant<bool, noexcept(declval<_Tp>() = declval<_Arg>()) >
-{
-};
-
-template <class _Tp, class _Arg>
-struct _LIBCPP_TEMPLATE_VIS is_nothrow_assignable
-    : public __libcpp_is_nothrow_assignable<is_assignable<_Tp, _Arg>::value, _Tp, _Arg>
-{
-};
-
-#endif // __has_builtin(__is_nothrow_assignable)
-
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class _Arg>
-inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<_Tp, _Arg>::value;
+inline constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_Tp, _Arg);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__utility/declval.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_nothrow_constructible)
 
-template <class _Tp, class... _Args>
+template <
+    class _Tp, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_nothrow_constructible
     : public integral_constant<bool, __is_nothrow_constructible(_Tp, _Args...)> {};
-
 #else
 
 template <bool, bool, class _Tp, class... _Args> struct __libcpp_is_nothrow_constructible;
 
 template <class _Tp, class... _Args>
 struct __libcpp_is_nothrow_constructible</*is constructible*/true, /*is reference*/false, _Tp, _Args...>
     : public integral_constant<bool, noexcept(_Tp(declval<_Args>()...))>
 {

libcxx/include/__type_traits/is_nothrow_copy_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
 
 #include <__config>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
-    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
-                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_assignable
+    : public integral_constant<
+          bool,
+          __is_nothrow_assignable(
+              typename add_lvalue_reference<_Tp>::type,
+              typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_copy_constructible.h

 #include <__type_traits/is_nothrow_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
+#ifdef _LIBCPP_COMPILER_GCC
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
     : public is_nothrow_constructible<_Tp,
                   typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
 
+#else // _LIBCPP_COMPILER_GCC
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_copy_constructible
+    : public integral_constant<
+          bool,
+          __is_nothrow_constructible(_Tp, typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
+
+#endif // _LIBCPP_COMPILER_GCC
+
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_default_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_default_constructible
-    : public is_nothrow_constructible<_Tp>
+    : public integral_constant<bool, __is_nothrow_constructible(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<_Tp>::value;
+inline constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_nothrow_destructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_DESTRUCTIBLE_H
 
 #include <__config>
-#include <__type_traits/add_const.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_destructible.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_scalar.h>
 #include <__type_traits/remove_all_extents.h>
 #include <__utility/declval.h>
 #include <cstddef>
 

libcxx/include/__type_traits/is_nothrow_move_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H
 
 #include <__config>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_nothrow_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
-    : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type,
-                                     typename add_rvalue_reference<_Tp>::type>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_assignable
+    : public integral_constant<
+          bool,
+          __is_nothrow_assignable(typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> {
+};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_nothrow_move_constructible.h

 #include <__type_traits/is_nothrow_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// TODO: remove this implementation once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is fixed
+#ifndef _LIBCPP_COMPILER_GCC
+
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
+    : public integral_constant<bool, __is_nothrow_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)>
+    {};
+
+#else // _LIBCPP_COMPILER_GCC
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_nothrow_move_constructible
     : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
     {};
 
+#endif // _LIBCPP_COMPILER_GCC
+
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_pod.h

 #include <__type_traits/integral_constant.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#if __has_builtin(__is_pod)
-
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
     : public integral_constant<bool, __is_pod(_Tp)> {};
 
-#else
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pod
-    : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value   &&
-                                     is_trivially_copy_constructible<_Tp>::value      &&
-                                     is_trivially_copy_assignable<_Tp>::value    &&
-                                     is_trivially_destructible<_Tp>::value> {};
-
-#endif // __has_builtin(__is_pod)
-
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_pod_v = is_pod<_Tp>::value;
+inline constexpr bool is_pod_v = __is_pod(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_POD_H

libcxx/include/__type_traits/is_standard_layout.h

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
-#if __has_builtin(__is_standard_layout)
     : public integral_constant<bool, __is_standard_layout(_Tp)>
-#else
-    : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>
-#endif
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
+inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_STANDARD_LAYOUT_H

libcxx/include/__type_traits/is_trivial.h

 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivial
-#if __has_builtin(__is_trivial)
     : public integral_constant<bool, __is_trivial(_Tp)>
-#else
-    : integral_constant<bool, is_trivially_copyable<_Tp>::value &&
-                                 is_trivially_default_constructible<_Tp>::value>
-#endif
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_trivial_v = is_trivial<_Tp>::value;
+inline constexpr bool is_trivial_v = __is_trivial(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIAL_H

libcxx/include/__type_traits/is_trivially_assignable.h

 
 template <class _Tp, class _Arg>
 struct is_trivially_assignable
     : integral_constant<bool, __is_trivially_assignable(_Tp, _Arg)>
 { };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class _Arg>
-inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<_Tp, _Arg>::value;
+inline constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_Tp, _Arg);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_constructible.h

 template <class _Tp, class... _Args>
 struct _LIBCPP_TEMPLATE_VIS is_trivially_constructible
     : integral_constant<bool, __is_trivially_constructible(_Tp, _Args...)>
 {
 };
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp, class... _Args>
-inline constexpr bool is_trivially_constructible_v = is_trivially_constructible<_Tp, _Args...>::value;
+inline constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Tp, _Args...);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_copy_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H
 
 #include <__config>
 #include <__type_traits/add_const.h>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
-    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
-                  typename add_lvalue_reference<typename add_const<_Tp>::type>::type> {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_assignable
+    : public integral_constant<
+          bool,
+          __is_trivially_assignable(
+              typename add_lvalue_reference<_Tp>::type,
+              typename add_lvalue_reference<typename add_const<_Tp>::type>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_trivially_copy_assignable_v = is_trivially_copy_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_copy_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copy_constructible
-    : public is_trivially_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type>
+    : public integral_constant<bool, __is_trivially_constructible(_Tp, typename add_lvalue_reference<const _Tp>::type)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPY_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_copyable.h

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_copyable
     : public integral_constant<bool, __is_trivially_copyable(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_trivially_copyable_v = is_trivially_copyable<_Tp>::value;
+inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_COPYABLE_H

libcxx/include/__type_traits/is_trivially_default_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_default_constructible
-    : public is_trivially_constructible<_Tp>
+    : public integral_constant<bool, __is_trivially_constructible(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
-inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<_Tp>::value;
+inline constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Tp);
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DEFAULT_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_destructible.h

 
 #elif __has_builtin(__has_trivial_destructor)
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
     : public integral_constant<bool, is_destructible<_Tp>::value && __has_trivial_destructor(_Tp)> {};
 
 #else
 
-template <class _Tp> struct __libcpp_trivial_destructor
-    : public integral_constant<bool, is_scalar<_Tp>::value ||
-                                     is_reference<_Tp>::value> {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible
-    : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {};
-
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_destructible<_Tp[]>
-    : public false_type {};
+#error is_trivially_destructible is not implemented
 
 #endif // __has_builtin(__is_trivially_destructible)
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_trivially_destructible_v = is_trivially_destructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_DESTRUCTIBLE_H

libcxx/include/__type_traits/is_trivially_move_assignable.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H
 
 #include <__config>
 #include <__type_traits/add_lvalue_reference.h>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_assignable.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
-    : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type,
-                                     typename add_rvalue_reference<_Tp>::type>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_move_assignable
+    : public integral_constant<
+          bool,
+          __is_trivially_assignable(
+              typename add_lvalue_reference<_Tp>::type, typename add_rvalue_reference<_Tp>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_ASSIGNABLE_H

libcxx/include/__type_traits/is_trivially_move_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/add_rvalue_reference.h>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/is_trivially_constructible.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
-    : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type>
-    {};
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS is_trivially_move_constructible
+    : public integral_constant<bool, __is_trivially_constructible(_Tp, typename add_rvalue_reference<_Tp>::type)> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_IS_TRIVIALLY_MOVE_CONSTRUCTIBLE_H

libcxx/include/__type_traits/is_union.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_UNION_H
 #define _LIBCPP___TYPE_TRAITS_IS_UNION_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
-#include <__type_traits/remove_cv.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union

libcxx/include/__type_traits/negation.h

 
 template <class _Pred>
 struct _Not : _BoolConstant<!_Pred::value> {};
 
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 struct negation : _Not<_Tp> {};
 template<class _Tp>
-inline constexpr bool negation_v = negation<_Tp>::value;
+inline constexpr bool negation_v = !_Tp::value;
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_NEGATION_H

libcxx/include/__type_traits/rank.h

 #include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+// TODO: Enable using the builtin __array_rank when https://llvm.org/PR57133 is resolved
+#if __has_builtin(__array_rank) && 0
+
+template <class _Tp>
+struct rank : integral_constant<size_t, __array_rank(_Tp)> {};
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank
     : public integral_constant<size_t, 0> {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
 template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS rank<_Tp[_Np]>
     : public integral_constant<size_t, rank<_Tp>::value + 1> {};
 
+#endif // __has_builtin(__array_rank)
+
 #if _LIBCPP_STD_VER > 14
 template <class _Tp>
 inline constexpr size_t rank_v = rank<_Tp>::value;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_RANK_H

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/common.h

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TEST_META_UNARY_COMP_COMMON_H
+#define TEST_META_UNARY_COMP_COMMON_H
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 11
+struct TrivialNotNoexcept {
+  TrivialNotNoexcept() noexcept(false)                                     = default;
+  TrivialNotNoexcept(const TrivialNotNoexcept&) noexcept(false)            = default;
+  TrivialNotNoexcept(TrivialNotNoexcept&&) noexcept(false)                 = default;
+  TrivialNotNoexcept& operator=(const TrivialNotNoexcept&) noexcept(false) = default;
+  TrivialNotNoexcept& operator=(TrivialNotNoexcept&&) noexcept(false)      = default;
+};
+#endif
+
+class Empty {};
+
+struct NotEmpty {
+  virtual ~NotEmpty();
+};
+
+union Union {};
+
+struct bit_zero {
+  int : 0;
+};
+
+struct A {
+  A();
+  A(const A&);
+  A& operator=(const A&);
+};
+
+class Abstract
+{
+    virtual ~Abstract() = 0;
+};
+
+#endif // TEST_META_UNARY_COMP_COMMON_H

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // template <class T, class... Args>
 //   struct is_nothrow_constructible;
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_is_nothrow_constructible()
 {
     static_assert(( std::is_nothrow_constructible<T>::value), "");
 #if TEST_STD_VER > 14
     static_assert(( std::is_nothrow_constructible_v<T>), "");
 #endif
 }

 void test_is_not_nothrow_constructible()
 {
     static_assert((!std::is_nothrow_constructible<T, A0, A1>::value), "");
 #if TEST_STD_VER > 14
     static_assert((!std::is_nothrow_constructible_v<T, A0, A1>), "");
 #endif
 }
 
-class Empty
-{
-};
-
-class NotEmpty
-{
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-class Abstract
-{
-    virtual ~Abstract() = 0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
 struct C
 {
     C(C&);  // not const
     void operator=(C&);  // not const
 };
 
 #if TEST_STD_VER >= 11
 struct Tuple {

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_nothrow_copy_assignable
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_has_nothrow_assign()
 {
     static_assert( std::is_nothrow_copy_assignable<T>::value, "");
 #if TEST_STD_VER > 14
     static_assert( std::is_nothrow_copy_assignable_v<T>, "");
 #endif
 }
 
 template <class T>
 void test_has_not_nothrow_assign()
 {
     static_assert(!std::is_nothrow_copy_assignable<T>::value, "");
 #if TEST_STD_VER > 14
     static_assert(!std::is_nothrow_copy_assignable_v<T>, "");
 #endif
 }
 
-class Empty
-{
-};
-
-struct NotEmpty
-{
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A& operator=(const A&);
-};
-
 int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
     test_has_nothrow_assign<Empty>();
     test_has_nothrow_assign<int>();
     test_has_nothrow_assign<double>();
     test_has_nothrow_assign<int*>();
     test_has_nothrow_assign<const int*>();
     test_has_nothrow_assign<NotEmpty>();
     test_has_nothrow_assign<bit_zero>();
 
+// TODO: enable the test for GCC once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is resolved
+#if TEST_STD_VER >= 11 && !defined(TEST_COMPILER_GCC)
+    test_has_not_nothrow_assign<TrivialNotNoexcept>();
+#endif
     test_has_not_nothrow_assign<const int>();
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
 
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_nothrow_copy_constructible
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_is_nothrow_copy_constructible()
 {
     static_assert( std::is_nothrow_copy_constructible<T>::value, "");
     static_assert( std::is_nothrow_copy_constructible<const T>::value, "");
 #if TEST_STD_VER > 14
     static_assert( std::is_nothrow_copy_constructible_v<T>, "");
     static_assert( std::is_nothrow_copy_constructible_v<const T>, "");

 #if TEST_STD_VER > 14
     static_assert(!std::is_nothrow_copy_constructible_v<T>, "");
     static_assert(!std::is_nothrow_copy_constructible_v<const T>, "");
     static_assert(!std::is_nothrow_copy_constructible_v<volatile T>, "");
     static_assert(!std::is_nothrow_copy_constructible_v<const volatile T>, "");
 #endif
 }
 
-class Empty
-{
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
 int main(int, char**)
 {
     test_has_not_nothrow_copy_constructor<void>();
     test_has_not_nothrow_copy_constructor<A>();
+#if TEST_STD_VER >= 11
+    test_has_not_nothrow_copy_constructor<TrivialNotNoexcept>();
+#endif
 
     test_is_nothrow_copy_constructible<int&>();
     test_is_nothrow_copy_constructible<Union>();
     test_is_nothrow_copy_constructible<Empty>();
     test_is_nothrow_copy_constructible<int>();
     test_is_nothrow_copy_constructible<double>();
     test_is_nothrow_copy_constructible<int*>();
     test_is_nothrow_copy_constructible<const int*>();
     test_is_nothrow_copy_constructible<bit_zero>();
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // is_nothrow_default_constructible
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_is_nothrow_default_constructible()
 {
     static_assert( std::is_nothrow_default_constructible<T>::value, "");
     static_assert( std::is_nothrow_default_constructible<const T>::value, "");
     static_assert( std::is_nothrow_default_constructible<volatile T>::value, "");
     static_assert( std::is_nothrow_default_constructible<const volatile T>::value, "");
 #if TEST_STD_VER > 14

 #if TEST_STD_VER > 14
     static_assert(!std::is_nothrow_default_constructible_v<T>, "");
     static_assert(!std::is_nothrow_default_constructible_v<const T>, "");
     static_assert(!std::is_nothrow_default_constructible_v<volatile T>, "");
     static_assert(!std::is_nothrow_default_constructible_v<const volatile T>, "");
 #endif
 }
 
-class Empty
-{
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A();
-};
-
 #if TEST_STD_VER >= 11
 struct DThrows
 {
     DThrows()  noexcept(true) {}
     ~DThrows() noexcept(false) {}
 };
 #endif
 
 int main(int, char**)
 {
     test_has_not_nothrow_default_constructor<void>();
     test_has_not_nothrow_default_constructor<int&>();
     test_has_not_nothrow_default_constructor<A>();
 #if TEST_STD_VER >= 11
     test_has_not_nothrow_default_constructor<DThrows>(); // This is LWG2116
+// TODO: enable the test for GCC once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is resolved
+#ifndef TEST_COMPILER_GCC
+    test_has_not_nothrow_default_constructor<TrivialNotNoexcept>();
+#endif
 #endif
 
     test_is_nothrow_default_constructible<Union>();
     test_is_nothrow_default_constructible<Empty>();
     test_is_nothrow_default_constructible<int>();
     test_is_nothrow_default_constructible<double>();
     test_is_nothrow_default_constructible<int*>();
     test_is_nothrow_default_constructible<const int*>();
     test_is_nothrow_default_constructible<char[3]>();
     test_is_nothrow_default_constructible<bit_zero>();
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // has_nothrow_move_assign
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_has_nothrow_assign()
 {
     static_assert( std::is_nothrow_move_assignable<T>::value, "");
 #if TEST_STD_VER > 14
     static_assert( std::is_nothrow_move_assignable_v<T>, "");
 #endif
 }
 
 template <class T>
 void test_has_not_nothrow_assign()
 {
     static_assert(!std::is_nothrow_move_assignable<T>::value, "");
 #if TEST_STD_VER > 14
     static_assert(!std::is_nothrow_move_assignable_v<T>, "");
 #endif
 }
 
-class Empty
-{
-};
-
-struct NotEmpty
-{
-    virtual ~NotEmpty();
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A& operator=(const A&);
-};
-
 int main(int, char**)
 {
     test_has_nothrow_assign<int&>();
     test_has_nothrow_assign<Union>();
     test_has_nothrow_assign<Empty>();
     test_has_nothrow_assign<int>();
     test_has_nothrow_assign<double>();
     test_has_nothrow_assign<int*>();
     test_has_nothrow_assign<const int*>();
     test_has_nothrow_assign<NotEmpty>();
     test_has_nothrow_assign<bit_zero>();
 
     test_has_not_nothrow_assign<void>();
     test_has_not_nothrow_assign<A>();
+// TODO: enable the test for GCC once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is resolved
+#if TEST_STD_VER >= 11 && !defined(TEST_COMPILER_GCC)
+    test_has_not_nothrow_assign<TrivialNotNoexcept>();
+#endif
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // has_nothrow_move_constructor
 
 #include <type_traits>
 #include "test_macros.h"
 
+#include "common.h"
+
 template <class T>
 void test_is_nothrow_move_constructible()
 {
     static_assert( std::is_nothrow_move_constructible<T>::value, "");
     static_assert( std::is_nothrow_move_constructible<const T>::value, "");
 #if TEST_STD_VER > 14
     static_assert( std::is_nothrow_move_constructible_v<T>, "");
     static_assert( std::is_nothrow_move_constructible_v<const T>, "");

 #if TEST_STD_VER > 14
     static_assert(!std::is_nothrow_move_constructible_v<T>, "");
     static_assert(!std::is_nothrow_move_constructible_v<const T>, "");
     static_assert(!std::is_nothrow_move_constructible_v<volatile T>, "");
     static_assert(!std::is_nothrow_move_constructible_v<const volatile T>, "");
 #endif
 }
 
-class Empty
-{
-};
-
-union Union {};
-
-struct bit_zero
-{
-    int :  0;
-};
-
-struct A
-{
-    A(const A&);
-};
-
 int main(int, char**)
 {
     test_has_not_nothrow_move_constructor<void>();
     test_has_not_nothrow_move_constructor<A>();
+// TODO: enable the test for GCC once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106611 is resolved
+#if TEST_STD_VER >= 11 && !defined(TEST_COMPILER_GCC)
+    test_has_not_nothrow_move_constructor<TrivialNotNoexcept>();
+#endif
 
     test_is_nothrow_move_constructible<int&>();
     test_is_nothrow_move_constructible<Union>();
     test_is_nothrow_move_constructible<Empty>();
     test_is_nothrow_move_constructible<int>();
     test_is_nothrow_move_constructible<double>();
     test_is_nothrow_move_constructible<int*>();
     test_is_nothrow_move_constructible<const int*>();
     test_is_nothrow_move_constructible<bit_zero>();
 
   return 0;
 }