[llvm] Remove llvm::is_trivially_{copy/move}_constructible (NFC)

[kazu]

Summary

This patch removes llvm::is_trivially_{copy/move}_constructible in
favor of std::is_trivially_{copy/move}_constructible.

The previous attempt to remove them in Dec 2020,
c8d406c93c5bb01599990201f78d8428dd29d289, broke builds with "some
versions of GCC" according to
6cd9608fb37ca2418fb44b57ec955bb5efe10689.

It's been 20 months since then, and the minimum requirement for GCC
has been updated to 7.1 from 5.1.

FWIW, I was able to build llvm with gcc 8.4.0.

[pavel.v.chupin]

@kazu, build is still broken with GCC7.3 after this change.
Basically the old comment by @miyuki at https://reviews.llvm.org/D92543 is still valid as far as I see. It doesn't look like mentioned problems are addressed.
Can you revert please?

[pavel.v.chupin]

It seems GCC7.5 works fine though...

[kazu]

In D132311#3797053, @pavel.v.chupin wrote:

@kazu, build is still broken with GCC7.3 after this change.
Basically the old comment by @miyuki at https://reviews.llvm.org/D92543 is still valid as far as I see. It doesn't look like mentioned problems are addressed.
Can you revert please?

Thank you for reporting the problem! I've reverted my change.

[MaskRay]

GCC 7.5.0 has a bug that, without this change, many SmallVector with a std::pair element type like SmallVector<std::pair<Instruction * const, Info>, 0> X; lead to spurious

/tmp/opt/gcc-7.5.0/include/c++/7.5.0/type_traits:878:48: error: constructor required before non-static data member for ‘...’ has been parsed

I think we should reconsider doing this and probably bumping the GCC version requirement to at least 7.5.0.

[MaskRay]

I have compiled GCC 7.3. FWIW ninja -C /tmp/out/custom-gcc-7.3 check-llvm gives me many errors related to structured bindings.

llvm/include/llvm/ADT/FunctionExtras.h

 /// - unique_function<int()> has a non-const operator().
 ///   It can hold functions with a non-const operator(), like mutable lambdas.
 template <typename FunctionT> class unique_function;
 
 namespace detail {
 
 template <typename T>
 using EnableIfTrivial =
-    std::enable_if_t<llvm::is_trivially_move_constructible<T>::value &&
+    std::enable_if_t<std::is_trivially_move_constructible<T>::value &&
                      std::is_trivially_destructible<T>::value>;
 template <typename CallableT, typename ThisT>
 using EnableUnlessSameType =
     std::enable_if_t<!std::is_same<remove_cvref_t<CallableT>, ThisT>::value>;
 template <typename CallableT, typename Ret, typename... Params>
 using EnableIfCallable = std::enable_if_t<std::disjunction<
     std::is_void<Ret>,
     std::is_same<decltype(std::declval<CallableT>()(std::declval<Params>()...)),
protected:
   //
   // The heuristic used is related to common ABI register passing conventions.
   // It doesn't have to be exact though, and in one way it is more strict
   // because we want to still be able to observe either moves *or* copies.
   template <typename T> struct AdjustedParamTBase {
     static_assert(!std::is_reference<T>::value,
                   "references should be handled by template specialization");
     using type = typename std::conditional<
-        llvm::is_trivially_copy_constructible<T>::value &&
-            llvm::is_trivially_move_constructible<T>::value &&
+        std::is_trivially_copy_constructible<T>::value &&
+            std::is_trivially_move_constructible<T>::value &&
             IsSizeLessThanThresholdT<T>::value,
         T, T &>::type;
   };
 
   // This specialization ensures that 'AdjustedParam<V<T>&>' or
   // 'AdjustedParam<V<T>&&>' does not trigger a compile-time error when 'T' is
   // an incomplete type and V a templated type.
   template <typename T> struct AdjustedParamTBase<T &> { using type = T &; };

llvm/include/llvm/ADT/Optional.h

 // the trivial specialization, the value_type must be trivially copy
 // constructible and trivially copy assignable due to =default implementations
 // of the copy/move constructor/assignment.  It does not follow that this is
 // necessarily the case std::is_trivially_copyable is true (hence the expanded
 // specialization condition).
 //
 // The move constructible / assignable conditions emulate the remaining behavior
 // of std::is_trivially_copyable.
-template <typename T,
-          bool = (llvm::is_trivially_copy_constructible<T>::value &&
+template <typename T, bool = (std::is_trivially_copy_constructible<T>::value &&
                               std::is_trivially_copy_assignable<T>::value &&
-                  (llvm::is_trivially_move_constructible<T>::value ||
+                              (std::is_trivially_move_constructible<T>::value ||
                                !std::is_move_constructible<T>::value) &&
                               (std::is_trivially_move_assignable<T>::value ||
                                !std::is_move_assignable<T>::value))>
 class OptionalStorage {
   union {
     char empty;
     T val;
   };
   bool hasVal = false;
 
 public:

llvm/include/llvm/ADT/SmallVector.h

 /// SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put
 /// method implementations that are designed to work with non-trivial T's.
 ///
 /// We approximate is_trivially_copyable with trivial move/copy construction and
 /// trivial destruction. While the standard doesn't specify that you're allowed
 /// copy these types with memcpy, there is no way for the type to observe this.
 /// This catches the important case of std::pair<POD, POD>, which is not
 /// trivially assignable.
-template <typename T, bool = (is_trivially_copy_constructible<T>::value) &&
-                             (is_trivially_move_constructible<T>::value) &&
+template <typename T, bool = (std::is_trivially_copy_constructible<T>::value) &&
+                             (std::is_trivially_move_constructible<T>::value) &&
                              std::is_trivially_destructible<T>::value>
 class SmallVectorTemplateBase : public SmallVectorTemplateCommon<T> {
   friend class SmallVectorTemplateCommon<T>;
 
 protected:
   static constexpr bool TakesParamByValue = false;
   using ValueParamT = const T &;
 

llvm/include/llvm/Support/type_traits.h

 };
 template <typename T>
 struct const_pointer_or_const_ref<T,
                                   std::enable_if_t<std::is_pointer<T>::value>> {
   using type = typename add_const_past_pointer<T>::type;
 };
 
 namespace detail {
-/// Internal utility to detect trivial copy construction.
-template<typename T> union copy_construction_triviality_helper {
-    T t;
-    copy_construction_triviality_helper() = default;
-    copy_construction_triviality_helper(const copy_construction_triviality_helper&) = default;
-    ~copy_construction_triviality_helper() = default;
-};
-/// Internal utility to detect trivial move construction.
-template<typename T> union move_construction_triviality_helper {
-    T t;
-    move_construction_triviality_helper() = default;
-    move_construction_triviality_helper(move_construction_triviality_helper&&) = default;
-    ~move_construction_triviality_helper() = default;
-};
-
 template<class T>
 union trivial_helper {
     T t;
 };
 
 } // end namespace detail
 
-/// An implementation of `std::is_trivially_copy_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_copy_constructible
-    : std::is_copy_constructible<
-          ::llvm::detail::copy_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_copy_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_copy_constructible<T &&> : std::false_type {};
-
-/// An implementation of `std::is_trivially_move_constructible` since we have
-/// users with STLs that don't yet include it.
-template <typename T>
-struct is_trivially_move_constructible
-    : std::is_move_constructible<
-          ::llvm::detail::move_construction_triviality_helper<T>> {};
-template <typename T>
-struct is_trivially_move_constructible<T &> : std::true_type {};
-template <typename T>
-struct is_trivially_move_constructible<T &&> : std::true_type {};
-
-
 template <typename T>
 struct is_copy_assignable {
   template<class F>
     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
     static std::false_type get(...);
     static constexpr bool value = decltype(get((T*)nullptr))::value;
 };
 

llvm/unittests/Support/TypeTraitsTest.cpp

 // Compile-time tests using static assert.
 namespace triviality {
 
 // Helper for compile time checking trivially copy constructible and trivially
 // move constructible type traits.
 template <typename T, bool IsTriviallyCopyConstructible,
           bool IsTriviallyMoveConstructible>
 void TrivialityTester() {
-  static_assert(llvm::is_trivially_copy_constructible<T>::value ==
+  static_assert(std::is_trivially_copy_constructible<T>::value ==
                     IsTriviallyCopyConstructible,
                 "Mismatch in expected trivial copy construction!");
-  static_assert(llvm::is_trivially_move_constructible<T>::value ==
+  static_assert(std::is_trivially_move_constructible<T>::value ==
                     IsTriviallyMoveConstructible,
                 "Mismatch in expected trivial move construction!");
 
 #if defined(_LIBCPP_VERSION) || defined(_MSC_VER)
   // On compilers with support for the standard traits, make sure they agree.
   static_assert(std::is_trivially_copy_constructible<T>::value ==
                     IsTriviallyCopyConstructible,
                 "Mismatch in expected trivial copy construction!");