Switch to std::is_trivially_move_constructible and std::is_trivially_copy_constructible

[MaskRay]

Summary

GCC<5 did not support std::is_trivially_{copy,move}_constructible. Now LLVM builds require 5.1
we can migrate to std:: versions.

[mehdi_amini]

Can you add the motivation/context in your commit message in general?
I can't tell if it is this just "cleanup" and if we upgraded a toolchain recently that makes these not needed anymore?

[miyuki]

Hi @MaskRay, this commit broke our builds which use GCC 7.3. I've posted some comments in D92591, but have just realized that it probably was not the right place. Could you please fix the breakage?

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 ReturnT, typename... ParamTs> class UniqueFunctionBase {
 protected:
   static constexpr size_t InlineStorageSize = sizeof(void *) * 3;
 
   template <typename T, class = void>
   struct IsSizeLessThanThresholdT : std::false_type {};
protected:
   // doing so would force things unnecessarily into memory.
   //
   // 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>
   using AdjustedParamT = typename std::conditional<
       !std::is_reference<T>::value &&
-          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;
 
   // The type of the erased function pointer we use as a callback to dispatch to
   // the stored callable when it is trivial to move and destroy.
   using CallPtrT = ReturnT (*)(void *CallableAddr,
                                AdjustedParamT<ParamTs>... Params);
   using MovePtrT = void (*)(void *LHSCallableAddr, void *RHSCallableAddr);

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> {
 protected:
   SmallVectorTemplateBase(size_t Size) : SmallVectorTemplateCommon<T>(Size) {}
 
   static void destroy_range(T *S, T *E) {
     while (S != E) {
       --E;

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/CMakeLists.txt

add_llvm_unittest(SupportTests
   TargetParserTest.cpp
   TaskQueueTest.cpp
   ThreadLocalTest.cpp
   ThreadPool.cpp
   Threading.cpp
   TimerTest.cpp
   ToolOutputFileTest.cpp
   TypeNameTest.cpp
-  TypeTraitsTest.cpp
   TrailingObjectsTest.cpp
   TrigramIndexTest.cpp
   UnicodeTest.cpp
   VersionTupleTest.cpp
   VirtualFileSystemTest.cpp
   WithColorTest.cpp
   YAMLIOTest.cpp
   YAMLParserTest.cpp

llvm/unittests/Support/TypeTraitsTest.cpp

-//===- TypeTraitsTest.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
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Support/type_traits.h"
-#include "gtest/gtest.h"
-
-namespace {
-
-// 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 ==
-                    IsTriviallyCopyConstructible,
-                "Mismatch in expected trivial copy construction!");
-  static_assert(llvm::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!");
-  static_assert(std::is_trivially_move_constructible<T>::value ==
-                    IsTriviallyMoveConstructible,
-                "Mismatch in expected trivial move construction!");
-#endif
-}
-
-template void TrivialityTester<int, true, true>();
-template void TrivialityTester<void *, true, true>();
-template void TrivialityTester<int &, true, true>();
-template void TrivialityTester<int &&, false, true>();
-
-struct X {};
-struct Y {
-  Y(const Y &);
-};
-struct Z {
-  Z(const Z &);
-  Z(Z &&);
-};
-struct A {
-  A(const A &) = default;
-  A(A &&);
-};
-struct B {
-  B(const B &);
-  B(B &&) = default;
-};
-
-template void TrivialityTester<X, true, true>();
-template void TrivialityTester<Y, false, false>();
-template void TrivialityTester<Z, false, false>();
-template void TrivialityTester<A, true, false>();
-template void TrivialityTester<B, false, true>();
-
-template void TrivialityTester<Z &, true, true>();
-template void TrivialityTester<A &, true, true>();
-template void TrivialityTester<B &, true, true>();
-template void TrivialityTester<Z &&, false, true>();
-template void TrivialityTester<A &&, false, true>();
-template void TrivialityTester<B &&, false, true>();
-
-TEST(Triviality, Tester) {
-  TrivialityTester<int, true, true>();
-  TrivialityTester<void *, true, true>();
-  TrivialityTester<int &, true, true>();
-  TrivialityTester<int &&, false, true>();
-
-  TrivialityTester<X, true, true>();
-  TrivialityTester<Y, false, false>();
-  TrivialityTester<Z, false, false>();
-  TrivialityTester<A, true, false>();
-  TrivialityTester<B, false, true>();
-
-  TrivialityTester<Z &, true, true>();
-  TrivialityTester<A &, true, true>();
-  TrivialityTester<B &, true, true>();
-  TrivialityTester<Z &&, false, true>();
-  TrivialityTester<A &&, false, true>();
-  TrivialityTester<B &&, false, true>();
-}
-
-} // namespace triviality
-
-} // end anonymous namespace

llvm/utils/gn/secondary/llvm/unittests/Support/BUILD.gn

sources = [
     "ThreadLocalTest.cpp",
     "ThreadPool.cpp",
     "Threading.cpp",
     "TimerTest.cpp",
     "ToolOutputFileTest.cpp",
     "TrailingObjectsTest.cpp",
     "TrigramIndexTest.cpp",
     "TypeNameTest.cpp",
-    "TypeTraitsTest.cpp",
     "UnicodeTest.cpp",
     "VersionTupleTest.cpp",
     "VirtualFileSystemTest.cpp",
     "WithColorTest.cpp",
     "YAMLIOTest.cpp",
     "YAMLParserTest.cpp",
     "formatted_raw_ostream_test.cpp",
     "raw_fd_stream_test.cpp",
     "raw_ostream_test.cpp",
     "raw_pwrite_stream_test.cpp",
     "raw_sha1_ostream_test.cpp",
     "xxhashTest.cpp",
   ]
 }