isPodLike: handle tuple and array

[jfb]

Summary

Just like isPodLike already handles pair, it should special-case tuple and array. This is really only useful for GCC before 5.0, so hopefully this workaround won't be around for long.

[jfb]

• Fix think-o.

[ldionne]

include/llvm/Support/type_traits.h

59

I'm not sure what the intent is, but std::tuple is not a POD even when its elements are -- it typically applies the EBO and I'm pretty sure it could actually use other tricks that would not make it a POD. Specifically, that would make it not Standard Layout AFAICT.

[ldionne]

include/llvm/Support/type_traits.h

59

https://wandbox.org/permlink/uTOa0CFb15ZBQby0

[jfb]

include/llvm/Support/type_traits.h

59

Interesting! The idea is to work around GCC < 5 not having std::is_trivially_copyable... and isPodLike already says that std::pair matches isPodLike which is actually not true as you demonstrate.

My use case was bit_cast of std::array which *is* trivially copyable.

So now I have to change isPodLike to remove the std::pair overload, not add one for std::tuple, and do add one for std::array.

I'm therefore not just making it more capable, I'm also fixing a bug with std::pair.

To make everything worst, this is slightly inconsistent because of GCC 5! Methink we really want to upgrade minimum compiler past GCC 5. This BoF sounds like a great place to discuss it:
https://llvm.org/devmtg/2018-10/talk-abstracts.html#bof3

[jfb]

include/llvm/Support/type_traits.h

59

I think I don't want to change isPodLike anymore. It's a crappy alternative to std::is_trivially_copyable. I think I want to special-case bit_cast instead to only check sizeof and builtin (if available) on GCC < 5, and rely on bots to catch bad usage otherwise (that is, most developers will do the full check, and outdated developers will break the bots).

I think isPodLike should die, but separately.

[jfb]

Let's do D51888 instead.

include/llvm/Support/type_traits.h

 // This file provides useful additions to the standard type_traits library.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_TYPE_TRAITS_H
 #define LLVM_SUPPORT_TYPE_TRAITS_H
 
 #include "llvm/Support/Compiler.h"
+#include <array>
+#include <tuple>
 #include <type_traits>
 #include <utility>
 
 #ifndef __has_feature
 #define LLVM_DEFINED_HAS_FEATURE
 #define __has_feature(x) 0
 #endif
 
#elif __has_feature(is_trivially_copyable)
   static const bool value = __is_trivially_copyable(T);
 #else
   // If we don't know anything else, we can (at least) assume that all non-class
   // types are PODs.
   static const bool value = !std::is_class<T>::value;
 #endif
 };
 
-// std::pair's are pod-like if their elements are.
+// These containers are POD-like if their elements are.
 template<typename T, typename U>
 struct isPodLike<std::pair<T, U>> {
   static const bool value = isPodLike<T>::value && isPodLike<U>::value;
 };
+template <> struct isPodLike<std::tuple<>> { static const bool value = true; };
+template <typename T> struct isPodLike<std::tuple<T>> {
+  static const bool value = isPodLike<T>::value;
+};
+template <typename T, typename... Ts> struct isPodLike<std::tuple<T, Ts...>> {
+  static const bool value =
+      isPodLike<T>::value && isPodLike<std::tuple<Ts...>>::value;
+};
+template <typename T, std::size_t S> struct isPodLike<std::array<T, S>> {
+  static const bool value = isPodLike<T>::value;
+};
 
 /// Metafunction that determines whether the given type is either an
 /// integral type or an enumeration type, including enum classes.
 ///
 /// Note that this accepts potentially more integral types than is_integral
 /// because it is based on being implicitly convertible to an integral type.
 /// Also note that enum classes aren't implicitly convertible to integral types,
 /// the value may therefore need to be explicitly converted before being used.