[libc++] Use builtin type traits whenever possible

[zoecarver]

Summary

This patch updates <type_traits> to use builtins wherever possible. This patch should increase performance greatly. When I compiled all the type traits tests before and after, I saw a 6.6% decrease in build time.

There are a few traits who's corresponding builtins do not work properly. See the comments in code. We will have to enable these traits only after a particular version of clang where the issue has been fixed.

[zoecarver]

• Enable use of builtins once fixed in clang

[zoecarver]

• remove array rank builtin (because it does not work properly)

[rsmith]

libcxx/include/type_traits

550

Nice idea. Is this conforming? Consider this somewhat-contrived example:

template<typename T> struct A {
  void f(is_same<T, int>) {}
  void f(is_same<T, float>) {}
  void f(false_type) {}
  void g() { f(disjunction<is_same<T, int>, is_same<T, float>, false_type>()); }
};

With a class template is_same, g() calls the version of f corresponding to the "right" option, but with the alias template version, instantiating A<T> is ill-formed because multiple signatures of f collide.

[zoecarver]

libcxx/include/type_traits

550

Arg, you are correct :)

The following seems to work, though:

template<bool _V>
struct m_bool_constant : integral_constant<bool, _V> { };

template <class _Tp, class _Up>
using m_is_same = m_bool_constant<__is_same(_Tp, _Up)>;

template<typename T> struct A {
  void f(m_is_same<T, int>) {}
  void f(m_is_same<T, float>) {}
  void f(false_type) {}
  void g() { f(disjunction<m_is_same<T, int>, m_is_same<T, float>, false_type>()); }
};

A<int> a{ };

What do you think of the above code?

[rsmith]

libcxx/include/type_traits

550

I think that still fails for A<char> (or for A<int> if we add a third f(m_is_same<...>) overload).

To strictly conform, I think we need is_same<A, B> to result in distinct types for all distinct (A, B) pairs. :-(

[zoecarver]

libcxx/include/type_traits

550

Alrighty, thanks for pointing that out. I think it's still faster to do the following:

template <class _Tp, class _Up>
struct m_is_same : integral_constant<bool, __is_same(_Tp, _Up)> { };

And that would satisfy the requirement of two distinct template types.

[ldionne]

Like Richard said before, we can't switch type traits to aliases. However, we can always do:

template <class _Tp>
struct is_const : integral_constant<bool, __is_const(_Tp)> { };

Can you switch back all the aliases to structs like that?

[zoecarver]

• Merge branch 'master' into use-builtin-type-traits
• fix: overload resolution issue
• fix: C++03 mode issue

[CaseyCarter]

libcxx/include/type_traits

758

This isn't equivalent: __is_void(cv-void) is true, but __libcpp_is_void<cv-void> is false.

[CaseyCarter]

libcxx/include/type_traits

562

Duplicate this on both branches of your new conditional, and optimize it on the __has_keyword(__is_same) branch?

567

It's peculiar that this (and line 576) uses #ifdef __clang__ vs. your __has_keyword(__is_same). Should the two be consistent? Should _IsSame and _IsNotSame move up into your new conditional?

672

Ditto "Should the variable template form be optimized as well to avoid the class template instantiation?" (I'll stop marking these, but IMO all of the is_meow_v variable templates should use the intrinsics directly rather than unnecessarily instantiate a class template.)

935

1. Why are these grouped like this, when none of the above are so grouped?
2. Shouldn't is_rvalue_reference and is_reference have leading double underscores?

1165

Should this be >= 1000 instead of > 900 to avoid catching e.g. 9.0.1, or has the bug been fixed on the Clang 9 branch also? (If so, the comment could be clarified.)

1394

C++20 would greatly appreciate a __remove_cvref(T) intrinsic which could be used to implement the above.

1441

Ditto "Should this actually be _LIBCPP_CLANG_VER >= 1000, or should the comment be clarified?"

libcxx/test/std/utilities/meta/meta.rel/is_same.pass.cpp

62

Maybe add a void fn(std::true_type) { } to ensure that std::is_same<T, meow> is not true_type even when T and meow are the same type?

63

1. std::disjunction is a C++17 feature.
2. std::disjunction</* ...stuff... */, std::false_type> is a different type than, but has the same base characteristic as std::disjunction</* ...stuff... */>, so the false_type here does nothing.
3. The body of this member function is not instantiated for any specialization of this class template in this test file, so it is extraneous.
4. This member does nothing useful, so there seems to be no need to instantiate it.

90

Defining variables suffices to instantiate the class template specializations, so this assert seems to serve no useful purpose.

[zoecarver]

libcxx/include/type_traits

562

I am planning on doing this but, I am going to do it in another patch.

567

IIRC clang has always had __is_same whereas that is not true for all these traits. I wasn't always sure (and I didn't want to write a lot of "random" version #ifs) so, to be safe, I looked for the keyword. It might be good to check for __clang__ as well, though.

672

Agreed. See my comment above.

758

I'll look into this and submit a patch, thanks.

935

1. I assumed that if one of them was defined then, they all would be defined.
2. Yep, I'll fix it.

1165

When clang 9.0.1 branched? I submitted it a few weeks ago. I'll see if I can figure out what version this is in an update the condition/comment.

1394

See D67052 and D67588 :)

libcxx/test/std/utilities/meta/meta.rel/is_same.pass.cpp

63

Thanks for the notes. I wrote this test a bit hastily. I'll fix it up.

90

It serves the purpose of unused variable compiler errors.

[zoecarver]

libcxx/include/type_traits

758

I see the issue, std::is_void functions the same way. I'll update the patch and pull __libcpp_is_void out of the conditional block.

1165

It doesn't look like clang 9.0.1 has been released yet so the fix will be in it. I'll update the comment.

[CaseyCarter]

libcxx/include/type_traits

567

Some Compiler Explorer research (https://godbolt.org/z/u1JVsC) shows that __is_same is supported at least back to clang 3.0.0, but __is_identifier (which is used to implement __has_keyword) was implemented in 3.5. Consequently there's a range of versions that will use __is_same here but not above, which is weird. It seems to me that line 547 should simply check #ifdef __clang__ since the library does not support clang versions that don't have __is_same (if any exist).

1394

I suppose the extra few nanoseconds that __remove_cv(__remove_reference(T)) costs over a __remove_cvref(T) is negligible. It's certainly in the noise compared to this alias that instantiates a class that instantiates another class that instantiates *two* classes. ;)

libcxx/test/std/utilities/meta/meta.rel/is_same.pass.cpp

90

I believe it's conventional in the test suite to silence unused variable warnings by casting to void, e.g., (void) t1;. In this particular case, however, you don't need the names for anything: OverloadTest only needs to be instantiated to achieve its purpose. You could simply create temporaries instead of named variables a la OverloadTest<int>{}; OverloadTest<char>{}; which avoids defining any variables in the first place.

[zoecarver]

• fix the std::is_same test

[zoecarver]

• update based on review

libcxx/include/type_traits

567

Clang 3.5.0 is the latest supported version so, that should be fine.

libcxx/test/std/utilities/meta/meta.rel/is_same.pass.cpp

90

I can't use braces because of C++03 mode. I fixed it by casting to void, thanks for the suggestion.

[zoecarver]

Ping @ldionne any other comments?

[zoecarver]

Ping. I'd like to get this approved before I rebase off master again. Any other review comments?

cc @ldionne @EricWF

[ldionne]

Thanks for your patience! This is looking good, but I do have some comments.

libcxx/include/type_traits

561

I think it's reasonable to change the meow_v variable templates to use intrinsics in this patch too, WDYT? Especially since you're doing it for is_integral_v below.

660

_LIBCPP_TEMPLATE_VIS (here and elsewhere)

758

I would remove that altogether since it's not used.

766

We could use this instead:

template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void : is_same<typename remove_cv<_Tp::type, void> {};

Arguably, only old compilers won't use the intrinsic, so I think this simplification (especially the removal of __libcpp_is_void) is worth it.

[zoecarver]

libcxx/include/type_traits

561

Yep. Will do.

[zoecarver]

• Rebase off master
• Add _LIBCPP_TEMPLATE_VIS everwhere
• Add *_v everywhere
• Remove add_reference and friends

[zoecarver]

• Support underlying_type and is_enum

[ldionne]

LGTM if the is_enum test is sufficient.

libcxx/include/type_traits

1114

__is_enum is not guarded by __has_keyword like the other ones?

[zoecarver]

I'll look into the CI failure.

libcxx/include/type_traits

1114

__is_enum (and __underlying_type) are already being used in the implementation. IIRC early versions of clang only supported __has_keyword. But I'm pretty sure we don't support any versions of clang that don't have both.

[zoecarver]

• Remove changes to __underlying_type (I didn't see the is_enum check.)

[zoecarver]

The CI just saved me at least half an hour of work (likely more) and three commits :)

I'll make sure the tests pass on the CI, then I'll commit.

[zoecarver]

74494d9992bdf266259f8add410f346971471c46 fixed both the issue with is_fundamental and is_compound (which failed because it's implemented using is_fundamental).

[zoecarver]

9e2207a00bddf9cf5f3f58b79dd63d01bb898198 adds the missing closing bracket in the is_void non-builtin implementation. If there's another failure I'll revert all three commits. It's extremely hard to test all paths of this patch because almost every compiler has a different set of the builtins.

[tcwang]

This patch has caused a regression on Chrome OS (https://bugs.chromium.org/p/chromium/issues/detail?id=1065276).

Some errors like:
In file included from ../../../libchrome-576279/platform2/libchrome/mojo/core/ports/event.cc:5:
libchrome-576279-r9: In file included from ../../../libchrome-576279/platform2/libchrome/mojo/core/ports/event.h:10:
libchrome-576279-r9: In file included from /usr/bin/../include/c++/v1/vector:274:
libchrome-576279-r9: In file included from /usr/bin/../include/c++/v1/__bit_reference:14:
libchrome-576279-r9: In file included from /usr/bin/../include/c++/v1/bit:57:
libchrome-576279-r9: /usr/bin/../include/c++/v1/limits:190:59: error: invalid operands to binary expression ('float128' and 'int')
libchrome-576279-r9: static _LIBCPP_CONSTEXPR const _Tp value = _Tp(_Tp(1) << digits);
libchrome-576279-r9: ~~~~~~ ^ ~~~~~~~~
libchrome-576279-r9: /usr/bin/../include/c++/v1/limits:211:49: note: in instantiation of template class 'std::1::libcpp_compute_min<float128, 127, true>' requested here
libchrome-576279-r9: static _LIBCPP_CONSTEXPR const type min = libcpp_compute_min<type, digits, is_signed>::value;
libchrome-576279-r9: ^
libchrome-576279-r9: /usr/bin/../include/c++/v1/limits:444:15: note: in instantiation of template class 'std::1::libcpp_numeric_limits<float128, true>' requested here
libchrome-576279-r9: : private libcpp_numeric_limits<typename remove_cv<_Tp>::type>
libchrome-576279-r9: ^
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/base/numerics/safe_conversions_impl.h:29:39: note: in instantiation of template class 'std::1::numeric_limits<float128>' requested here
libchrome-576279-r9: ? std::numeric_limits<NumericType>::max_exponent
libchrome-576279-r9: ^
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/base/numerics/safe_conversions_impl.h:175:7: note: in instantiation of template class 'base::internal::MaxExponent<float128>' requested here
libchrome-576279-r9: MaxExponent<Dst>::value > MaxExponent<Src>::value
libchrome-576279-r9: ^
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/base/numerics/safe_conversions.h:240:29: note: in instantiation of template class 'base::internal::StaticDstRangeRelationToSrcRange<float128, unsigned long, base::internal::INTEGER_REPRESENTATION_SIGNED, base::internal::INTEGER_REPRESENTATION_UNSIGNED>' requested here
libchrome-576279-r9: static const bool value = StaticDstRangeRelationToSrcRange<Dst, Src>::value ==
libchrome-576279-r9: ^
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/base/numerics/safe_conversions.h:286:17: note: in instantiation of template class 'base::internal::IsNumericRangeContained<float128, unsigned long, void>' requested here
libchrome-576279-r9: IsNumericRangeContained<Dst, T>::value>::type* = nullptr>
libchrome-576279-r9: ^
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/base/numerics/safe_conversions.h:287:13: note: while substituting prior template arguments into non-type template parameter [with Dst = float128]
libchrome-576279-r9: constexpr operator Dst() const {
libchrome-576279-r9: ^~~~~~~~~~~~~~~~~~~~~~
libchrome-576279-r9: ../../../libchrome-576279/platform2/libchrome/mojo/core/ports/event.cc:171:55: note: while substituting deduced template arguments into function template 'operator type-parameter-0-0' [with Dst = float128, $1 = (no value)]
libchrome-576279-r9: if (!total_size.IsValid() || num_bytes < total_size.ValueOrDie())

[zoecarver]

@tcwang I'll try to put together a fix later today. My guess is that one of these type trait builtins doesn't play nice with __float128. But, that's only a guess.

[zoecarver]

Also, in the future, it's easier to read the error if you use triple backticks. That way the formatting/indentation isn't messed up.

[tcwang]

event.ii2 MBDownload

event.ii is the preprocessed test case that can be used to reproduce the error. I am trying to use c-reduce to reduce but due to many errors (25 in total), the reduced test case is actually having other errors. I will try to reduce it in the meantime. But just in case this can help the author to figure out the problem. Also attached the interestingness test in test.sh{F11652738}

[zoecarver]

@tcwang here's you're reproducer: https://godbolt.org/z/RJtTBG

Looks like we don't have any __float128 tests not only in numeric limits but in libc++ altogether.

Anyway, to address the problem: is_arithmetic_v<__float128> is true after this patch and false before this patch. It seems like returning true is the correct behavior so the change should probably happen in numeric limits. It's not entirely clear what that change should be, though. Do we want to support __float128 in numeric_limits? We don't seem to support it anywhere else. Maybe add a static_assert so that future bugs are easier to track down?

In the meantime, numeric_limits just returned 0 for numeric_limits< __float128 >::min() so maybe you can replace the current use with that?

[zoecarver]

I'm going to plan to revert the is_arithmetic and is_floating_point changes later today. Any objections?

[manojgupta]

Copying an email reply to phab thread from @EricWF , not sure why it did not make it here.

We should revert the change for is_arithmetic and is_floating_point.

Marshall and I have discussed the __float128 issue previously, but we couldn't reach an agreement that it should be handled as an extension.
For that reason, I think we should go back to the old behavior.

[tcwang]

In D67900#1954028, @zoecarver wrote:

@tcwang here's you're reproducer: https://godbolt.org/z/RJtTBG

Thank you!

Looks like we don't have any __float128 tests not only in numeric limits but in libc++ altogether.

Anyway, to address the problem: is_arithmetic_v<__float128> is true after this patch and false before this patch. It seems like returning true is the correct behavior so the change should probably happen in numeric limits.

Thanks again for figuring out the problem.

It's not entirely clear what that change should be, though. Do we want to support __float128 in numeric_limits? We don't seem to support it anywhere else. Maybe add a static_assert so that future bugs are easier to track down?

In the meantime, numeric_limits just returned 0 for numeric_limits< __float128 >::min() so maybe you can replace the current use with that?

I don't think I understand what to replace. From the log I showed before, the error was from the header file vector all the way to /usr/bin/../include/c++/v1/limits. Plus we don't own the code that has the error, and I didn't see float128 directly in the code. And I see many places using ::max() (not float128 type, or not clear to me it's float128 type). So I don't know how to proceed with it...

[zoecarver]

@tcanens I didn't look closely enough at the error. It looks like it's because vector uses numeric limits. I'll revert the changes which will fix the problem so, don't worry about it :)

[tcanens]

In D67900#1955278, @zoecarver wrote:

@tcanens I didn't look closely enough at the error. It looks like it's because vector uses numeric limits. I'll revert the changes which will fix the problem so, don't worry about it :)

I'm guessing that you tagged the wrong person?

[zoecarver]

@tcanens sorry about that. Yes, I meant @tcwang.

[tcwang]

Thank you! Just let me know when the new patch is submitted.

[zoecarver]

@tcwang fixed in e6a39f00e8d0cd3684df54fb03d288efe2969202.

[tcwang]

@zoecarver Thank you!

libcxx/include/type_traits

 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS enable_if<true, _Tp> {typedef _Tp type;};
 
 #if _LIBCPP_STD_VER > 11
 template <bool _Bp, class _Tp = void> using enable_if_t = typename enable_if<_Bp, _Tp>::type;
 #endif
 
 // is_same
 
+#if __has_keyword(__is_same)
+
+template <class _Tp, class _Up>
+struct is_same : _BoolConstant<__is_same(_Tp, _Up)> { };
+
+#else
+
 template <class _Tp, class _Up> struct _LIBCPP_TEMPLATE_VIS is_same           : public false_type {};
 template <class _Tp>            struct _LIBCPP_TEMPLATE_VIS is_same<_Tp, _Tp> : public true_type {};
 
+#endif // __is_same
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp, class _Up>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_same_v
     = is_same<_Tp, _Up>::value;
 #endif
 
 template <class _Tp, class _Up>
 using _IsSame = _BoolConstant<
 #ifdef __clang__
     __is_same(_Tp, _Up)
 #else
     _VSTD::is_same<_Tp, _Up>::value
 #endif
 >;
 
 template <class _Tp, class _Up>
 using _IsNotSame = _BoolConstant<

 #endif
 
 struct __two {char __lx[2];};
 
 // helper class:
 
 // is_const
 
+#if __has_keyword(__is_const)
+
+template <class _Tp>
+struct is_const : _BoolConstant<__is_const(_Tp)> { };
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const            : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_const<_Tp const> : public true_type {};
 
+#endif // __has_keyword(__is_const)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_const_v
     = is_const<_Tp>::value;
 #endif
 
 // is_volatile
 
+#if __has_keyword(__is_volatile)
+
+template <class _Tp>
+struct is_volatile : _BoolConstant<__is_volatile(_Tp)> { };
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile               : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_volatile<_Tp volatile> : public true_type {};
 
+#endif // __has_keyword(__is_volatile)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_volatile_v
     = is_volatile<_Tp>::value;
 #endif
 
 // remove_const
 
+#if __has_keyword(__remove_const)
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_const {typedef __remove_const(_Tp) type;};
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const            {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_const<const _Tp> {typedef _Tp type;};
+
+#endif // __has_keyword(__remove_const)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_const_t = typename remove_const<_Tp>::type;
 #endif
 
 // remove_volatile
 
+#if __has_keyword(__remove_volatile)
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_volatile {typedef __remove_volatile(_Tp) type;};
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile               {typedef _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_volatile<volatile _Tp> {typedef _Tp type;};
+
+#endif // __has_keyword(__remove_volatile)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_volatile_t = typename remove_volatile<_Tp>::type;
 #endif
 
 // remove_cv
 
+#if __has_keyword(__remove_cv)
+
+template <class _Tp>
+struct _LIBCPP_TEMPLATE_VIS remove_cv {typedef __remove_cv(_Tp) type;};
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_cv
 {typedef typename remove_volatile<typename remove_const<_Tp>::type>::type type;};
+
+#endif // __has_keyword(__remove_cv)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_cv_t = typename remove_cv<_Tp>::type;
 #endif
 
 // is_void
 
+#if __has_keyword(__is_void)
+
+template <class _Tp>
+struct is_void : _BoolConstant<__is_void(_Tp)> { };
+
+// This is never used but, we define it anyway for consistency.
+template <class _Tp>
+struct __libcpp_is_void : _BoolConstant<__is_void(_Tp)> { };
+
+#else
+
 template <class _Tp> struct __libcpp_is_void       : public false_type {};
 template <>          struct __libcpp_is_void<void> : public true_type {};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_void
     : public __libcpp_is_void<typename remove_cv<_Tp>::type> {};
 
+#endif // __has_keyword(__is_void)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_void_v
     = is_void<_Tp>::value;
 #endif
 
 // __is_nullptr_t
 

 template <>          struct __libcpp_is_integral<unsigned long>      : public true_type {};
 template <>          struct __libcpp_is_integral<long long>          : public true_type {};
 template <>          struct __libcpp_is_integral<unsigned long long> : public true_type {};
 #ifndef _LIBCPP_HAS_NO_INT128
 template <>          struct __libcpp_is_integral<__int128_t>         : public true_type {};
 template <>          struct __libcpp_is_integral<__uint128_t>        : public true_type {};
 #endif
 
+#if __has_keyword(__is_integral)
+
+template <class _Tp>
+struct is_integral : _BoolConstant<__is_integral(_Tp)> { };
+
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v = __is_integral(_Tp);
+#endif
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_integral
     : public __libcpp_is_integral<typename remove_cv<_Tp>::type> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_integral_v
     = is_integral<_Tp>::value;
 #endif
 
+#endif // __has_keyword(__is_integral)
+
 // is_floating_point
 
 template <class _Tp> struct __libcpp_is_floating_point              : public false_type {};
 template <>          struct __libcpp_is_floating_point<float>       : public true_type {};
 template <>          struct __libcpp_is_floating_point<double>      : public true_type {};
 template <>          struct __libcpp_is_floating_point<long double> : public true_type {};
 
+#if __has_keyword(__is_floating_point)
+
+template <class _Tp>
+struct is_floating_point : _BoolConstant<__is_floating_point(_Tp)> { };
+
+#if _LIBCPP_STD_VER > 14
+template <class _Tp>
+_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v = __is_floating_point(_Tp);
+#endif
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_floating_point
     : public __libcpp_is_floating_point<typename remove_cv<_Tp>::type> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_floating_point_v
     = is_floating_point<_Tp>::value;
 #endif
 
+#endif // __has_keyword(__is_floating_point)
+
 // is_array
 
+#if __has_keyword(__is_array)
+
+template <class _Tp>
+struct is_array : _BoolConstant<__is_array(_Tp)> { };
+
+#else
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array
     : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[]>
     : public true_type {};
 template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS is_array<_Tp[_Np]>
     : public true_type {};
 
+#endif // __has_keyword(__is_array)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v
     = is_array<_Tp>::value;
 #endif
 
 // is_pointer
 
 template <class _Tp> struct __libcpp_is_pointer       : public false_type {};
 template <class _Tp> struct __libcpp_is_pointer<_Tp*> : public true_type {};
 
 template <class _Tp> struct __libcpp_remove_objc_qualifiers { typedef _Tp type; };
 #if defined(_LIBCPP_HAS_OBJC_ARC)
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __strong> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __weak> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __autoreleasing> { typedef _Tp type; };
 template <class _Tp> struct __libcpp_remove_objc_qualifiers<_Tp __unsafe_unretained> { typedef _Tp type; };
 #endif
 
+#if __has_keyword(__is_pointer)
+
+template<class _Tp>
+struct is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
+
+#else // __has_keyword(__is_pointer)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_pointer
     : public __libcpp_is_pointer<typename __libcpp_remove_objc_qualifiers<typename remove_cv<_Tp>::type>::type> {};
 
+#endif // __has_keyword(__is_pointer)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v
     = is_pointer<_Tp>::value;
 #endif
 
 // is_reference
 
+#if __has_keyword(__is_lvalue_reference) && \
+    __has_keyword(is_rvalue_reference) && \
+    __has_keyword(is_reference)
+
+template<class _Tp>
+struct is_lvalue_reference : _BoolConstant<__is_lvalue_reference(_Tp)> { };
+
+template<class _Tp>
+struct is_rvalue_reference : _BoolConstant<__is_rvalue_reference(_Tp)> { };
+
+template<class _Tp>
+struct is_reference : _BoolConstant<__is_reference(_Tp)> { };
+
+#else // __has_keyword(__is_lvalue_reference) && etc...
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference       : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_lvalue_reference<_Tp&> : public true_type {};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference        : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_rvalue_reference<_Tp&&> : public true_type {};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference        : public false_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&>  : public true_type {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_reference<_Tp&&> : public true_type {};
 
+#endif // __has_keyword(__is_lvalue_reference) && etc...
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_reference_v
     = is_reference<_Tp>::value;
 
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_lvalue_reference_v
     = is_lvalue_reference<_Tp>::value;
 
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_rvalue_reference_v
     = is_rvalue_reference<_Tp>::value;
 #endif
+
 // is_union
 
 #if __has_feature(is_union) || defined(_LIBCPP_COMPILER_GCC)
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_union
     : public integral_constant<bool, __is_union(_Tp)> {};
 
 #else

 template <class _Tp, class _Up> struct __libcpp_is_member_pointer<_Tp _Up::*> {
   enum {
     __is_member = true,
     __is_func = is_function<_Tp>::value,
     __is_obj = !__is_func,
   };
 };
 
+#if __has_keyword(__is_member_function_pointer)
+
+template<class _Tp>
+struct is_member_function_pointer : _BoolConstant<__is_member_function_pointer(_Tp)> { };
+
+#else // __has_keyword(__is_member_function_pointer)
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_function_pointer
     : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_func > {};
 
+#endif // __has_keyword(__is_member_function_pointer)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_function_pointer_v
     = is_member_function_pointer<_Tp>::value;
 #endif
 
 // is_member_pointer
 
+#if __has_keyword(__is_member_pointer)
+
+template<class _Tp>
+struct is_member_pointer : _BoolConstant<__is_member_pointer(_Tp)> { };
+
+#else // __has_keyword(__is_member_pointer)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_pointer
  : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_member > {};
 
+ #endif // __has_keyword(__is_member_pointer)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_pointer_v
     = is_member_pointer<_Tp>::value;
 #endif
 
 // is_member_object_pointer
 
+#if __has_keyword(__is_member_object_pointer)
+
+template<class _Tp>
+struct is_member_object_pointer : _BoolConstant<__is_member_object_pointer(_Tp)> { };
+
+#else // __has_keyword(__is_member_object_pointer)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_member_object_pointer
     : public _BoolConstant< __libcpp_is_member_pointer<typename remove_cv<_Tp>::type>::__is_obj >  {};
 
+#endif // __has_keyword(__is_member_object_pointer)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_member_object_pointer_v
     = is_member_object_pointer<_Tp>::value;
 #endif
 
 // is_enum
 
 #if __has_feature(is_enum) || defined(_LIBCPP_COMPILER_GCC)
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
     : public integral_constant<bool, __is_enum(_Tp)> {};
 
 #else
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_enum
     : public integral_constant<bool, !is_void<_Tp>::value             &&

 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_enum_v
     = is_enum<_Tp>::value;
 #endif
 
 // is_arithmetic
 
+#if __has_keyword(__is_arithmetic)
+
+template<class _Tp>
+struct is_arithmetic : _BoolConstant<__is_arithmetic(_Tp)> { };
+
+#else // __has_keyword(__is_arithmetic)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_arithmetic
     : public integral_constant<bool, is_integral<_Tp>::value      ||
                                      is_floating_point<_Tp>::value> {};
 
+#endif // __has_keyword(__is_arithmetic)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v
     = is_arithmetic<_Tp>::value;
 #endif
 
 // is_fundamental
 
+// Before clang 10, this builtin did not work for nullptr_t
+#if __has_keyword(__is_fundamental) && _LIBCPP_CLANG_VER > 900
+
+template<class _Tp>
+struct is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
+
+#else // __has_keyword(__is_fundamental)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_fundamental
     : public integral_constant<bool, is_void<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value ||
                                      is_arithmetic<_Tp>::value> {};
 
+#endif // __has_keyword(__is_fundamental)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v
     = is_fundamental<_Tp>::value;
 #endif
 
 // is_scalar
 
+// >= 11 because in C++03 nullptr isn't actually nullptr
+#if __has_keyword(__is_scalar) && !defined(_LIBCPP_CXX03_LANG)
+
+template<class _Tp>
+struct is_scalar : _BoolConstant<__is_scalar(_Tp)> { };
+
+#else // __has_keyword(__is_scalar)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_scalar
     : public integral_constant<bool, is_arithmetic<_Tp>::value     ||
                                      is_member_pointer<_Tp>::value ||
                                      is_pointer<_Tp>::value        ||
                                      __is_nullptr_t<_Tp>::value    ||
                                      is_enum<_Tp>::value           > {};
 
 template <> struct _LIBCPP_TEMPLATE_VIS is_scalar<nullptr_t> : public true_type {};
 
+#endif // __has_keyword(__is_scalar)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_scalar_v
     = is_scalar<_Tp>::value;
 #endif
 
 // is_object
 
+#if __has_keyword(__is_object)
+
+template<class _Tp>
+struct is_object : _BoolConstant<__is_object(_Tp)> { };
+
+#else // __has_keyword(__is_object)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_object
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_array<_Tp>::value  ||
                                      is_union<_Tp>::value  ||
                                      is_class<_Tp>::value  > {};
 
+#endif // __has_keyword(__is_object)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_object_v
     = is_object<_Tp>::value;
 #endif
 
 // is_compound
 
+// >= 11 because in C++03 nullptr isn't actually nullptr
+#if __has_keyword(__is_compound) && !defined(_LIBCPP_CXX03_LANG)
+
+template<class _Tp>
+struct is_compound : _BoolConstant<__is_compound(_Tp)> { };
+
+#else // __has_keyword(__is_compound)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_compound
     : public integral_constant<bool, !is_fundamental<_Tp>::value> {};
 
+#endif // __has_keyword(__is_compound)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_compound_v
     = is_compound<_Tp>::value;
 #endif
 
 
 // __is_referenceable  [defns.referenceable]

 };
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_cv_t = typename add_cv<_Tp>::type;
 #endif
 
 // remove_reference
 
+#if __has_keyword(__remove_reference)
+
+template<class _Tp>
+struct remove_reference { typedef __remove_reference(_Tp) type; };
+
+#else // __has_keyword(__remove_reference)
+
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference        {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&>  {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS remove_reference<_Tp&&> {typedef _LIBCPP_NODEBUG_TYPE _Tp type;};
 
+#endif // __has_keyword(__remove_reference)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using remove_reference_t = typename remove_reference<_Tp>::type;
 #endif
 
 // add_lvalue_reference
 
+#if __has_keyword(__add_lvalue_reference)
+
+template<class _Tp>
+struct add_lvalue_reference { typedef __add_lvalue_reference(_Tp) type; };
+
+#else // __has_keyword(__add_lvalue_reference)
+
 template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_lvalue_reference_impl            { typedef _LIBCPP_NODEBUG_TYPE _Tp  type; };
 template <class _Tp                                       > struct __add_lvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE _Tp& type; };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_lvalue_reference
 {typedef _LIBCPP_NODEBUG_TYPE typename  __add_lvalue_reference_impl<_Tp>::type type;};
 
+#endif // __has_keyword(__add_lvalue_reference)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
 #endif
 
+// add_rvalue_reference
+
+#if __has_keyword(__add_rvalue_reference)
+
+template<class _Tp>
+struct add_rvalue_reference { typedef __add_rvalue_reference(_Tp) type; };
+
+#else // __has_keyword(__add_rvalue_reference)
+
 template <class _Tp, bool = __is_referenceable<_Tp>::value> struct __add_rvalue_reference_impl            { typedef _LIBCPP_NODEBUG_TYPE  _Tp   type; };
 template <class _Tp                                       > struct __add_rvalue_reference_impl<_Tp, true> { typedef _LIBCPP_NODEBUG_TYPE  _Tp&& type; };
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
 {typedef _LIBCPP_NODEBUG_TYPE  typename __add_rvalue_reference_impl<_Tp>::type type;};
 
+#endif // __has_keyword(__add_rvalue_reference)
+
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
 #endif
 
 template <class _Tp> _Tp&& __declval(int);
 template <class _Tp> _Tp   __declval(long);
 
 template <class _Tp>

 struct __is_same_uncvref : _IsSame<typename __uncvref<_Tp>::type,
                                    typename __uncvref<_Up>::type> {};
 
 #if _LIBCPP_STD_VER > 17
 // remove_cvref - same as __uncvref
 template <class _Tp>
 struct remove_cvref : public __uncvref<_Tp> {};
 
 template <class _Tp> using remove_cvref_t = typename remove_cvref<_Tp>::type;
 #endif
 
 
 struct __any
 {
     __any(...);
 };
 

 // type_identity
 #if _LIBCPP_STD_VER > 17
 template<class _Tp> struct type_identity { typedef _Tp type; };
 template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
 #endif
 
 // is_signed
 
+// Before clang 10, this builtin did not work for floating points or enums
+#if __has_keyword(__is_signed) && _LIBCPP_CLANG_VER > 900
+
+template<class _Tp>
+struct is_signed : _BoolConstant<__is_signed(_Tp)> { };
+
+#else // __has_keyword(__is_signed)
+
 template <class _Tp, bool = is_integral<_Tp>::value>
 struct __libcpp_is_signed_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(-1) < _Tp(0)) {};
 
 template <class _Tp>
 struct __libcpp_is_signed_impl<_Tp, false> : public true_type {};  // floating point
 
 template <class _Tp, bool = is_arithmetic<_Tp>::value>
 struct __libcpp_is_signed : public __libcpp_is_signed_impl<_Tp> {};
 
 template <class _Tp> struct __libcpp_is_signed<_Tp, false> : public false_type {};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_signed : public __libcpp_is_signed<_Tp> {};
 
+#endif // __has_keyword(__is_signed)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v
     = is_signed<_Tp>::value;
 #endif
 
 // is_unsigned
 
+#if __has_keyword(__is_unsigned)
+
+template<class _Tp>
+struct is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
+
+#else // __has_keyword(__is_unsigned)
+
 template <class _Tp, bool = is_integral<_Tp>::value>
 struct __libcpp_is_unsigned_impl : public _LIBCPP_BOOL_CONSTANT(_Tp(0) < _Tp(-1)) {};
 
 template <class _Tp>
 struct __libcpp_is_unsigned_impl<_Tp, false> : public false_type {};  // floating point
 
 template <class _Tp, bool = is_arithmetic<_Tp>::value>
 struct __libcpp_is_unsigned : public __libcpp_is_unsigned_impl<_Tp> {};
 
 template <class _Tp> struct __libcpp_is_unsigned<_Tp, false> : public false_type {};
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_unsigned : public __libcpp_is_unsigned<_Tp> {};
 
+#endif // __has_keyword(__is_unsigned)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v
     = is_unsigned<_Tp>::value;
 #endif
 
 // rank
 
 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> {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t rank_v
     = rank<_Tp>::value;
 #endif
 
 // extent
 
+#if __has_keyword(__array_extent)
+
+template<class _Tp, size_t _Dim = 0>
+struct extent : integral_constant<size_t, __array_extent(_Tp, _Dim)> { };
+
+#else // __has_keyword(__array_extent)
+
 template <class _Tp, unsigned _Ip = 0> struct _LIBCPP_TEMPLATE_VIS extent
     : public integral_constant<size_t, 0> {};
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], 0>
     : public integral_constant<size_t, 0> {};
 template <class _Tp, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
 template <class _Tp, size_t _Np> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], 0>
     : public integral_constant<size_t, _Np> {};
 template <class _Tp, size_t _Np, unsigned _Ip> struct _LIBCPP_TEMPLATE_VIS extent<_Tp[_Np], _Ip>
     : public integral_constant<size_t, extent<_Tp, _Ip-1>::value> {};
 
+#endif // __has_keyword(__array_extent)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp, unsigned _Ip = 0>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR size_t extent_v
     = extent<_Tp, _Ip>::value;
 #endif
 
 // remove_extent
 

 #if _LIBCPP_STD_VER > 11
 template <class ..._Tp> using common_type_t = typename common_type<_Tp...>::type;
 #endif
 
 // is_assignable
 
 template<typename, typename _Tp> struct __select_2nd { typedef _LIBCPP_NODEBUG_TYPE _Tp type; };
 
+#if __has_keyword(__is_assignable)
+
+template<class _Tp, class _Up>
+struct is_assignable : _BoolConstant<__is_assignable(_Tp, _Up)> { };
+
+#else // __has_keyword(__is_assignable)
+
 template <class _Tp, class _Arg>
 typename __select_2nd<decltype((_VSTD::declval<_Tp>() = _VSTD::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> {};
 
+#endif  // __has_keyword(__is_assignable)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp, class _Arg>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_assignable_v
     = is_assignable<_Tp, _Arg>::value;
 #endif
 
 // is_copy_assignable
 

 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_move_assignable_v
     = is_move_assignable<_Tp>::value;
 #endif
 
 // is_destructible
 
+#if __has_keyword(__is_destructible)
+
+template<class _Tp>
+struct is_destructible : _BoolConstant<__is_destructible(_Tp)> { };
+
+#else // __has_keyword(__is_destructible)
+
 //  if it's a reference, return true
 //  if it's a function, return false
 //  if it's   void,     return false
 //  if it's an array of unknown bound, return false
 //  Otherwise, return "std::declval<_Up&>().~_Up()" is well-formed
 //    where _Up is remove_all_extents<_Tp>::type
 
 template <class>

 template <class _Tp>
 struct is_destructible<_Tp[]>
     : public _VSTD::false_type {};
 
 template <>
 struct is_destructible<void>
     : public _VSTD::false_type {};
 
+#endif // __has_keyword(__is_destructible)
+
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_destructible_v
     = is_destructible<_Tp>::value;
 #endif
 
 // move
 

libcxx/test/std/utilities/meta/meta.rel/is_same.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_same
 
 #include <type_traits>
+#include <cassert>
 
 #include "test_macros.h"
 
 template <class T, class U>
 void test_is_same()
 {
     static_assert(( std::is_same<T, U>::value), "");
     static_assert((!std::is_same<const T, U>::value), "");

 }
 
 template <class T, class U>
 void test_is_not_same()
 {
     static_assert((!std::is_same<T, U>::value), "");
 }
 
+#if TEST_STD_VER > 11
+template <class T>
+struct OverloadTest
+{
+    int dummy = 1;
+  
+    void fn(std::is_same<T, int>) { }
+    void fn(std::is_same<T, float>) { }
+    void fn(std::false_type) { }
+    void x() { std::disjunction<std::is_same<T, int>, std::is_same<T, float>, std::false_type>(); }
+};
+#endif
+
 class Class
 {
 public:
     ~Class();
 };
 
 int main(int, char**)
 {
     test_is_same<int, int>();
     test_is_same<void, void>();
     test_is_same<Class, Class>();
     test_is_same<int*, int*>();
     test_is_same_ref<int&, int&>();
 
     test_is_not_same<int, void>();
     test_is_not_same<void, Class>();
     test_is_not_same<Class, int*>();
     test_is_not_same<int*, int&>();
     test_is_not_same<int&, int>();
   
+#if TEST_STD_VER > 11
+    OverloadTest<int> t1;
+    OverloadTest<char> t2;
+    assert(t1.dummy && t2.dummy);
+#endif
   return 0;
 }