Fix SFINAE in llvm::bit_cast.

[jlebar]

Summary

As far as I can tell, the SFINAE was broken; there is no such thing as
std::is_trivially_constructible<T>::type.

[jlebar]

Attempt to remove files that should have been ignored.

[jlebar]

Undo overzealous re-clang-formatting.

[jlebar]

"How did this ever work?" Since is_trivially_constructible<T>::type doesn't exist, wouldn't this always be a substitution failure?

[jlebar]

Since is_trivially_constructible<T>::type doesn't exist, wouldn't this always be a substitution failure?

Ah, ::type exists, it is either true_type or false_type. I still don't see how this ever worked, though, because then there's still no SFINAE...

[jlebar]

Rebase

[jlebar]

Lint: Pre-merge checks

I chose not to reformat this patch because it's a tricky diff that I wanted to keep small and I'm going to reformat it in a later patch that changes all enable_if to enable_if_t anyway. But I can reformat it if reviewers would like.

[grandinj]

Hah, nice catch, this sounds like something that might make a nice clang-tidy check?

[jlebar]

Thank you for the reviews!

this sounds like something that might make a nice clang-tidy check?

Good idea! Is there a place where people keep track of open clang-tidy check requests?

(Another way this could have been caught is if LLVM supported "negative compilation tests", i.e. unit tests that check that certain code doesn't compile.)

llvm/include/llvm/ADT/bit.h

 #include <cstring>
 #include <type_traits>
 
 namespace llvm {
 
 // This implementation of bit_cast is different from the C++17 one in two ways:
 //  - It isn't constexpr because that requires compiler support.
 //  - It requires trivially-constructible To, to avoid UB in the implementation.
 template <typename To, typename From
           , typename = typename std::enable_if<sizeof(To) == sizeof(From)>::type
 #if (__has_feature(is_trivially_constructible) && defined(_LIBCPP_VERSION)) || \
     (defined(__GNUC__) && __GNUC__ >= 5)
-          , typename = typename std::is_trivially_constructible<To>::type
+          , typename = typename std::enable_if<
+              std::is_trivially_constructible<To>::value>::type
 #elif __has_feature(is_trivially_constructible)
           , typename = typename std::enable_if<__is_trivially_constructible(To)>::type
 #else
   // See comment below.
 #endif
 #if (__has_feature(is_trivially_copyable) && defined(_LIBCPP_VERSION)) || \
     (defined(__GNUC__) && __GNUC__ >= 5)
           , typename = typename std::enable_if<std::is_trivially_copyable<To>::value>::type
           , typename = typename std::enable_if<std::is_trivially_copyable<From>::value>::type
 #elif __has_feature(is_trivially_copyable)
           , typename = typename std::enable_if<__is_trivially_copyable(To)>::type
           , typename = typename std::enable_if<__is_trivially_copyable(From)>::type
 #else
 // This case is GCC 4.x. clang with libc++ or libstdc++ never get here. Unlike
 // llvm/Support/type_traits.h's is_trivially_copyable we don't want to
 // provide a good-enough answer here: developers in that configuration will hit
 // compilation failures on the bots instead of locally. That's acceptable
 // because it's very few developers, and only until we move past C++11.
 #endif
 >
 inline To bit_cast(const From &from) noexcept {
   To to;
   std::memcpy(&to, &from, sizeof(To));
   return to;
 }
 
 } // namespace llvm
 
 #endif