[libc] Use LIBC_HAS_BUILTIN instead of __has_builtin directly.

[sivachandra]

This is fine with me except for referring to gcc < 10. We do not officially support gcc < 12.2. This will not change unless of course someone comes in and first prepares the code base for gcc < 12.2, and then stands up a bot for it. I am not opposed to this change because we already have precedents in the code base checking for availability of __has_builtin. So, title your patch to something like, Use __has_builtin only if available.

libc/src/__support/CPP/type_traits.h

224

Use https://github.com/llvm/llvm-project/blob/main/libc/src/__support/macros/config.h.

[mikhail.ramalho]

Use LIBC_HAS_BUILTIN instead of creating our own

libc/src/__support/CPP/type_traits.h

 //===-- Self contained C++ type traits --------------------------*- C++ -*-===//
 //
 // 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 LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
 #include "src/__support/macros/attributes.h"
+#include "src/__support/macros/config.h"
 
 #include <stddef.h> // For size_t.
 
 namespace __llvm_libc {
 namespace cpp {
 
 template <typename T> struct type_identity {
   using type = T;

 // this when LIBC_INLINE_VAR uses [[clang::internal_linkage]].
 template <typename F, typename T>
 constexpr bool
     is_convertible_v<F, T,
                      details::void_t<decltype(details::convertible_to_helper<T>(
                          declval<F>()))>> = true;
 
 namespace details {
-#if __has_builtin(__is_lvalue_reference) &&                                    \
-    __has_builtin(__is_rvalue_reference) && __has_builtin(__is_reference)
+#if LIBC_HAS_BUILTIN(__is_lvalue_reference) &&                                 \
+    LIBC_HAS_BUILTIN(__is_rvalue_reference) &&                                 \
+    LIBC_HAS_BUILTIN(__is_reference)
 
 template <typename T>
 struct is_lvalue_reference : bool_constant<__is_lvalue_reference(T)> {};
 template <typename T>
 struct is_rvalue_reference : bool_constant<__is_rvalue_reference(T)> {};
 template <typename T> struct is_reference : bool_constant<__is_reference(T)> {};
 
-#else // __has_builtin(__is_lvalue_reference) && etc...
+#else // LIBC_HAS_BUILTIN(__is_lvalue_reference) && etc...
 
 template <typename T> struct is_lvalue_reference : public false_type {};
 template <typename T> struct is_lvalue_reference<T &> : public true_type {};
 
 template <typename T> struct is_rvalue_reference : public false_type {};
 template <typename T> struct is_rvalue_reference<T &&> : public true_type {};
 
 template <typename T> struct is_reference : public false_type {};
 template <typename T> struct is_reference<T &> : public true_type {};
 template <typename T> struct is_reference<T &&> : public true_type {};
 
-#endif // __has_builtin(__is_lvalue_reference) && etc...
+#endif // LIBC_HAS_BUILTIN(__is_lvalue_reference) && etc...
 
-#if __has_builtin(__remove_all_extents)
+#if LIBC_HAS_BUILTIN(__remove_all_extents)
 template <typename T> using __remove_all_extents_t = __remove_all_extents(T);
 #else
 template <typename T> struct remove_all_extents {
   typedef T type;
 };
 template <typename T> struct remove_all_extents<T[]> {
   typedef typename remove_all_extents<T>::type type;
 };
 template <typename T, size_t _Np> struct remove_all_extents<T[_Np]> {
   typedef typename remove_all_extents<T>::type type;
 };
 
 template <typename T>
 using __remove_all_extents_t = typename remove_all_extents<T>::type;
-#endif // __has_builtin(__remove_all_extents)
+#endif // LIBC_HAS_BUILTIN(__remove_all_extents)
 
-#if __has_builtin(__is_function)
+#if LIBC_HAS_BUILTIN(__is_function)
 
 template <typename T>
 struct is_function : integral_constant<bool, __is_function(T)> {};
 
 #else
 
 template <typename T>
 struct is_function
     : public integral_constant<bool, !(is_reference<T>::value ||
                                        is_const<const T>::value)> {};
 
-#endif // __has_builtin(__is_function)
+#endif // LIBC_HAS_BUILTIN(__is_function)
 
-#if __has_builtin(__is_destructible)
+#if LIBC_HAS_BUILTIN(__is_destructible)
 
 template <typename T>
 struct is_destructible : bool_constant<__is_destructible(T)> {};
 
-#else // __has_builtin(__is_destructible)
+#else // LIBC_HAS_BUILTIN(__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 "declval<T&>().~T()" is well-formed
 //    where T is remove_all_extents<T>::type
 

 struct __destructible_false<T, true> : public false_type {};
 
 template <typename T>
 struct is_destructible : public __destructible_false<T, is_function<T>::value> {
 };
 template <typename T> struct is_destructible<T[]> : public false_type {};
 template <> struct is_destructible<void> : public false_type {};
 
-#endif // __has_builtin(__is_destructible)
+#endif // LIBC_HAS_BUILTIN(__is_destructible)
 } // namespace details
 
-#if __has_builtin(__is_trivially_destructible)
+#if LIBC_HAS_BUILTIN(__is_trivially_destructible)
 
 template <typename T>
 struct is_trivially_destructible
     : public integral_constant<bool, __is_trivially_destructible(T)> {};
 
-#elif __has_builtin(__has_trivial_destructor)
-
+#else
 template <typename T>
 struct is_trivially_destructible
     : public integral_constant<
           bool, __llvm_libc::cpp::details::is_destructible<T>::value
                     &&__has_trivial_destructor(T)> {};
-
-#endif // __has_builtin(__is_trivially_destructible)
+#endif // LIBC_HAS_BUILTIN(__is_trivially_destructible)
 
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H