From c9bcdd0195f9c7c3a16bb44e767a439220887f1f Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Wed, 17 Mar 2021 14:38:33 -0600
Subject: [PATCH 01/11] Use a union in Variant for safe type punning

Create a `VaraintUnion` that is an actual C++ `union` to store the data
in a `Variant`.

You may be asking yourself, why not just use an `std::aligned_union`
rather than a real union type? That was our first implementation, but
the problem is that the `std::aligned_union` reference needs to be
recast to the actual type. Typically you would do that with
`reinterpret_cast`. However, doing that leads to undefined behavior. The
C++ compiler assumes that 2 pointers of different types point to
different memory (even if it is clear that they are set to the same
address). That means optimizers can remove code because it "knows" that
data in one type cannot affect data in another type. To safely change
the type of an `std::aligned_union`, you really have to do an
`std::memcpy`. This is problematic for types that cannot be trivially
copied. Another problem is that we found that device compilers do not
optimize the memcpy as well as most CPU compilers. Likely, memcpy is
used much less frequently on GPU devices.
---
 .../exec/internal/testing/UnitTestVariant.cxx |   62 +-
 vtkm/internal/VariantImpl.h                   |  281 +-
 vtkm/internal/VariantImplDetail.h             | 4051 ++++++++++-------
 vtkm/internal/VariantImplDetail.h.in          |  335 +-
 4 files changed, 2764 insertions(+), 1965 deletions(-)

diff --git a/vtkm/exec/internal/testing/UnitTestVariant.cxx b/vtkm/exec/internal/testing/UnitTestVariant.cxx
index 424665f1a..bc37bec6d 100644
--- a/vtkm/exec/internal/testing/UnitTestVariant.cxx
+++ b/vtkm/exec/internal/testing/UnitTestVariant.cxx
@@ -248,50 +248,51 @@ void TestTriviallyCopyable()
   VTKM_STATIC_ASSERT(!std::is_trivial<TrivialCopy>::value);
 
   // A variant of trivially constructable things should be trivially constructable
-  VTKM_STATIC_ASSERT((vtkm::exec::internal::detail::AllTriviallyConstructible<float, int>::value));
+  VTKM_STATIC_ASSERT((vtkmstd::is_trivially_constructible<
+                      vtkm::exec::internal::detail::VariantUnion<float, int>>::value));
   VTKM_STATIC_ASSERT(
-    (std::is_trivially_constructible<vtkm::exec::internal::Variant<float, int>>::value));
+    (vtkmstd::is_trivially_constructible<vtkm::exec::internal::Variant<float, int>>::value));
 
   // A variant of trivially copyable things should be trivially copyable
-  VTKM_STATIC_ASSERT(
-    (vtkm::exec::internal::detail::AllTriviallyCopyable<float, int, TrivialCopy>::value));
-  VTKM_STATIC_ASSERT(
-    (std::is_trivially_copyable<vtkm::exec::internal::Variant<float, int, TrivialCopy>>::value));
+  VTKM_STATIC_ASSERT((vtkmstd::is_trivially_copyable<
+                      vtkm::exec::internal::detail::VariantUnion<float, int, TrivialCopy>>::value));
+  VTKM_STATIC_ASSERT((
+    vtkmstd::is_trivially_copyable<vtkm::exec::internal::Variant<float, int, TrivialCopy>>::value));
 
   // A variant of any non-trivially constructable things is not trivially copyable
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyConstructible<NonTrivial, float, int>::value));
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyConstructible<float, NonTrivial, int>::value));
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyConstructible<float, int, NonTrivial>::value));
-  VTKM_STATIC_ASSERT((!std::is_trivially_constructible<
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
+                      vtkm::exec::internal::detail::VariantUnion<NonTrivial, float, int>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
+                      vtkm::exec::internal::detail::VariantUnion<float, NonTrivial, int>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
+                      vtkm::exec::internal::detail::VariantUnion<float, int, NonTrivial>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
                       vtkm::exec::internal::Variant<NonTrivial, float, int>>::value));
-  VTKM_STATIC_ASSERT((!std::is_trivially_constructible<
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
                       vtkm::exec::internal::Variant<float, NonTrivial, int>>::value));
-  VTKM_STATIC_ASSERT((!std::is_trivially_constructible<
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_constructible<
                       vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
 
   // A variant of any non-trivially copyable things is not trivially copyable
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyCopyable<NonTrivial, float, int>::value));
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyCopyable<float, NonTrivial, int>::value));
-  VTKM_STATIC_ASSERT(
-    (!vtkm::exec::internal::detail::AllTriviallyCopyable<float, int, NonTrivial>::value));
-  VTKM_STATIC_ASSERT(
-    (!std::is_trivially_copyable<vtkm::exec::internal::Variant<NonTrivial, float, int>>::value));
-  VTKM_STATIC_ASSERT(
-    (!std::is_trivially_copyable<vtkm::exec::internal::Variant<float, NonTrivial, int>>::value));
-  VTKM_STATIC_ASSERT(
-    (!std::is_trivially_copyable<vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_copyable<
+                      vtkm::exec::internal::detail::VariantUnion<NonTrivial, float, int>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_copyable<
+                      vtkm::exec::internal::detail::VariantUnion<float, NonTrivial, int>>::value));
+  VTKM_STATIC_ASSERT((!vtkmstd::is_trivially_copyable<
+                      vtkm::exec::internal::detail::VariantUnion<float, int, NonTrivial>>::value));
+  VTKM_STATIC_ASSERT((
+    !vtkmstd::is_trivially_copyable<vtkm::exec::internal::Variant<NonTrivial, float, int>>::value));
+  VTKM_STATIC_ASSERT((
+    !vtkmstd::is_trivially_copyable<vtkm::exec::internal::Variant<float, NonTrivial, int>>::value));
+  VTKM_STATIC_ASSERT((
+    !vtkmstd::is_trivially_copyable<vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
 
   // A variant of trivial things should be trivial
-  VTKM_STATIC_ASSERT((std::is_trivial<vtkm::exec::internal::Variant<float, int>>::value));
+  VTKM_STATIC_ASSERT((vtkmstd::is_trivial<vtkm::exec::internal::Variant<float, int>>::value));
   VTKM_STATIC_ASSERT(
-    (!std::is_trivial<vtkm::exec::internal::Variant<float, int, TrivialCopy>>::value));
+    (!vtkmstd::is_trivial<vtkm::exec::internal::Variant<float, int, TrivialCopy>>::value));
   VTKM_STATIC_ASSERT(
-    (!std::is_trivial<vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
+    (!vtkmstd::is_trivial<vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
 #endif // !VTKM_USING_GLIBCXX_4
 }
 
@@ -434,6 +435,7 @@ struct CountConstructDestruct
     ++(*this->Count);
   }
   ~CountConstructDestruct() { --(*this->Count); }
+  CountConstructDestruct& operator=(const CountConstructDestruct&) = delete;
 };
 
 void TestCopyDestroy()
diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index 64a7b387f..5e6784d14 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -20,8 +20,7 @@
 #include <vtkm/Deprecated.h>
 #include <vtkm/List.h>
 
-#include <vtkmstd/aligned_union.h>
-#include <vtkmstd/is_trivial.h>
+#include <vtkm/internal/Assume.h>
 
 namespace vtkm
 {
@@ -37,12 +36,33 @@ class Variant;
 namespace detail
 {
 
+// --------------------------------------------------------------------------------
+// Helper classes for Variant
+
+template <typename UnionType>
+struct VariantUnionToListImpl;
+template <typename... Ts>
+struct VariantUnionToListImpl<detail::VariantUnionTD<Ts...>>
+{
+  using type = vtkm::List<Ts...>;
+};
+template <typename... Ts>
+struct VariantUnionToListImpl<detail::VariantUnionNTD<Ts...>>
+{
+  using type = vtkm::List<Ts...>;
+};
+
+template <typename UnionType>
+using VariantUnionToList =
+  typename VariantUnionToListImpl<typename std::decay<UnionType>::type>::type;
+
 struct VariantCopyFunctor
 {
-  template <typename T>
-  VTK_M_DEVICE void operator()(const T& src, void* destPointer) const noexcept
+  template <typename T, typename UnionType>
+  VTK_M_DEVICE void operator()(const T& src, UnionType& destUnion) const noexcept
   {
-    new (destPointer) T(src);
+    constexpr vtkm::IdComponent Index = vtkm::ListIndexOf<VariantUnionToList<UnionType>, T>::value;
+    new (&VariantUnionGet<Index>(destUnion)) T(src);
   }
 };
 
@@ -68,115 +88,12 @@ struct VariantCheckType
   VTKM_STATIC_ASSERT_MSG(!std::is_pointer<T>::value, "Pointers are not allowed in VTK-m Variant.");
 };
 
-template <typename... Ts>
-struct AllTriviallyCopyable;
-
-template <>
-struct AllTriviallyCopyable<> : std::true_type
-{
-};
-
-template <typename T0>
-struct AllTriviallyCopyable<T0>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value)>
-{
-};
-
-template <typename T0, typename T1>
-struct AllTriviallyCopyable<T0, T1>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_copyable<T0>::value &&
-                            vtkmstd::is_trivially_copyable<T1>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2>
-struct AllTriviallyCopyable<T0, T1, T2>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_copyable<T0>::value &&
-                            vtkmstd::is_trivially_copyable<T1>::value &&
-                            vtkmstd::is_trivially_copyable<T2>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2, typename T3>
-struct AllTriviallyCopyable<T0, T1, T2, T3>
-  : std::integral_constant<
-      bool,
-      (vtkmstd::is_trivially_copyable<T0>::value && vtkmstd::is_trivially_copyable<T1>::value &&
-       vtkmstd::is_trivially_copyable<T2>::value && vtkmstd::is_trivially_copyable<T3>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename... Ts>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, Ts...>
-  : std::integral_constant<
-      bool,
-      (vtkmstd::is_trivially_copyable<T0>::value && vtkmstd::is_trivially_copyable<T1>::value &&
-       vtkmstd::is_trivially_copyable<T2>::value && vtkmstd::is_trivially_copyable<T3>::value &&
-       vtkmstd::is_trivially_copyable<T4>::value && AllTriviallyCopyable<Ts...>::value)>
-{
-};
-
 template <typename VariantType>
 struct VariantTriviallyCopyable;
 
 template <typename... Ts>
 struct VariantTriviallyCopyable<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>>
-  : AllTriviallyCopyable<Ts...>
-{
-};
-
-template <typename... Ts>
-struct AllTriviallyConstructible;
-
-template <>
-struct AllTriviallyConstructible<> : std::true_type
-{
-};
-
-template <typename T0>
-struct AllTriviallyConstructible<T0>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value)>
-{
-};
-
-template <typename T0, typename T1>
-struct AllTriviallyConstructible<T0, T1>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_constructible<T0>::value &&
-                            vtkmstd::is_trivially_constructible<T1>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2>
-struct AllTriviallyConstructible<T0, T1, T2>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_constructible<T0>::value &&
-                            vtkmstd::is_trivially_constructible<T1>::value &&
-                            vtkmstd::is_trivially_constructible<T2>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2, typename T3>
-struct AllTriviallyConstructible<T0, T1, T2, T3>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_constructible<T0>::value &&
-                            vtkmstd::is_trivially_constructible<T1>::value &&
-                            vtkmstd::is_trivially_constructible<T2>::value &&
-                            vtkmstd::is_trivially_constructible<T3>::value)>
-{
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename... Ts>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, Ts...>
-  : std::integral_constant<bool,
-                           (vtkmstd::is_trivially_constructible<T0>::value &&
-                            vtkmstd::is_trivially_constructible<T1>::value &&
-                            vtkmstd::is_trivially_constructible<T2>::value &&
-                            vtkmstd::is_trivially_constructible<T3>::value &&
-                            vtkmstd::is_trivially_constructible<T4>::value &&
-                            AllTriviallyConstructible<Ts...>::value)>
+  : vtkmstd::is_trivially_copyable<VariantUnion<Ts...>>
 {
 };
 
@@ -185,26 +102,28 @@ struct VariantTriviallyConstructible;
 
 template <typename... Ts>
 struct VariantTriviallyConstructible<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>>
-  : AllTriviallyConstructible<Ts...>
+  : vtkmstd::is_trivially_constructible<VariantUnion<Ts...>>
 {
 };
 
+// --------------------------------------------------------------------------------
+// Variant superclass that defines its storage
 template <typename... Ts>
 struct VariantStorageImpl
 {
-  typename vtkmstd::aligned_union<0, Ts...>::type Storage;
-
+  VariantUnion<Ts...> Storage;
   vtkm::IdComponent Index;
 
+  VariantStorageImpl() = default;
+
+  VTK_M_DEVICE VariantStorageImpl(vtkm::internal::NullType dummy)
+    : Storage({ dummy })
+  {
+  }
+
   template <vtkm::IdComponent Index>
   using TypeAt = typename vtkm::ListAt<vtkm::List<Ts...>, Index>;
 
-  VTK_M_DEVICE void* GetPointer() { return reinterpret_cast<void*>(&this->Storage); }
-  VTK_M_DEVICE const void* GetPointer() const
-  {
-    return reinterpret_cast<const void*>(&this->Storage);
-  }
-
   VTK_M_DEVICE vtkm::IdComponent GetIndex() const noexcept { return this->Index; }
   VTK_M_DEVICE bool IsValid() const noexcept
   {
@@ -226,12 +145,11 @@ struct VariantStorageImpl
       -> decltype(f(std::declval<const TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
-    return detail::VariantCastAndCallImpl<decltype(f(std::declval<const TypeAt<0>&>(), args...))>(
-      brigand::list<Ts...>{},
-      this->GetIndex(),
-      std::forward<Functor>(f),
-      this->GetPointer(),
-      std::forward<Args>(args)...);
+    return detail::VariantCastAndCallImpl(vtkm::ListSize<vtkm::List<Ts...>>{},
+                                          this->GetIndex(),
+                                          std::forward<Functor>(f),
+                                          this->Storage,
+                                          std::forward<Args>(args)...);
   }
 
   template <typename Functor, typename... Args>
@@ -240,15 +158,17 @@ struct VariantStorageImpl
     -> decltype(f(std::declval<TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
-    return detail::VariantCastAndCallImpl<decltype(f(std::declval<TypeAt<0>&>(), args...))>(
-      brigand::list<Ts...>{},
-      this->GetIndex(),
-      std::forward<Functor>(f),
-      this->GetPointer(),
-      std::forward<Args>(args)...);
+    return detail::VariantCastAndCallImpl(vtkm::ListSize<vtkm::List<Ts...>>{},
+                                          this->GetIndex(),
+                                          std::forward<Functor>(f),
+                                          this->Storage,
+                                          std::forward<Args>(args)...);
   }
 };
 
+// --------------------------------------------------------------------------------
+// Variant superclass that helps preserve trivially copyable and trivially constructable
+// properties where possible.
 template <typename VariantType,
           typename TriviallyConstructible =
             typename VariantTriviallyConstructible<VariantType>::type,
@@ -277,7 +197,11 @@ struct VariantConstructorImpl<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>,
                               std::false_type,
                               std::true_type> : VariantStorageImpl<Ts...>
 {
-  VTK_M_DEVICE VariantConstructorImpl() { this->Index = -1; }
+  VTK_M_DEVICE VariantConstructorImpl()
+    : VariantStorageImpl<Ts...>(vtkm::internal::NullType{})
+  {
+    this->Index = -1;
+  }
 
   // Any trivially copyable class is trivially destructable.
   ~VariantConstructorImpl() = default;
@@ -294,19 +218,24 @@ struct VariantConstructorImpl<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>,
                               construct_type,
                               std::false_type> : VariantStorageImpl<Ts...>
 {
-  VTK_M_DEVICE VariantConstructorImpl() { this->Index = -1; }
+  VTK_M_DEVICE VariantConstructorImpl()
+    : VariantStorageImpl<Ts...>(vtkm::internal::NullType{})
+  {
+    this->Index = -1;
+  }
   VTK_M_DEVICE ~VariantConstructorImpl() { this->Reset(); }
 
   VTK_M_DEVICE VariantConstructorImpl(const VariantConstructorImpl& src) noexcept
+    : VariantStorageImpl<Ts...>(vtkm::internal::NullType{})
   {
-    src.CastAndCall(VariantCopyFunctor{}, this->GetPointer());
+    src.CastAndCall(VariantCopyFunctor{}, this->Storage);
     this->Index = src.Index;
   }
 
   VTK_M_DEVICE VariantConstructorImpl& operator=(const VariantConstructorImpl& src) noexcept
   {
     this->Reset();
-    src.CastAndCall(detail::VariantCopyFunctor{}, this->GetPointer());
+    src.CastAndCall(detail::VariantCopyFunctor{}, this->Storage);
     this->Index = src.Index;
     return *this;
   }
@@ -323,20 +252,6 @@ class Variant : detail::VariantConstructorImpl<Variant<Ts...>>
   using CheckTypes = vtkm::List<detail::VariantCheckType<Ts>...>;
 
 public:
-  /// Returns the index of the type of object this variant is storing. If no object is currently
-  /// stored (i.e. the `Variant` is invalid), an invalid is returned.
-  ///
-  VTK_M_DEVICE vtkm::IdComponent GetIndex() const noexcept { return this->Superclass::GetIndex(); }
-
-  /// Returns true if this `Variant` is storing an object from one of the types in the template
-  /// list, false otherwise.
-  ///
-  /// Note that if this `Variant` was not initialized with an object, the result of `IsValid`
-  /// is undefined. The `Variant` could report itself as validly containing an object that
-  /// is trivially constructed.
-  ///
-  VTK_M_DEVICE bool IsValid() const noexcept { return this->Superclass::IsValid(); }
-
   /// Type that converts to a std::integral_constant containing the index of the given type (or
   /// -1 if that type is not in the list).
   template <typename T>
@@ -353,12 +268,29 @@ public:
   /// Type that converts to the type at the given index.
   ///
   template <vtkm::IdComponent Index>
-  using TypeAt = typename Superclass::template TypeAt<Index>;
+  using TypeAt = typename vtkm::ListAt<vtkm::List<Ts...>, Index>;
 
   /// The number of types representable by this Variant.
   ///
   static constexpr vtkm::IdComponent NumberOfTypes = vtkm::IdComponent{ sizeof...(Ts) };
 
+  /// Returns the index of the type of object this variant is storing. If no object is currently
+  /// stored (i.e. the `Variant` is invalid), an invalid is returned.
+  ///
+  VTK_M_DEVICE vtkm::IdComponent GetIndex() const noexcept { return this->Index; }
+
+  /// Returns true if this `Variant` is storing an object from one of the types in the template
+  /// list, false otherwise.
+  ///
+  /// Note that if this `Variant` was not initialized with an object, the result of `IsValid`
+  /// is undefined. The `Variant` could report itself as validly containing an object that
+  /// is trivially constructed.
+  ///
+  VTK_M_DEVICE bool IsValid() const noexcept
+  {
+    return (this->Index >= 0) && (this->Index < NumberOfTypes);
+  }
+
   Variant() = default;
   ~Variant() = default;
   Variant(const Variant&) = default;
@@ -373,19 +305,15 @@ public:
     // Might be a way to use an enable_if to enforce a proper type.
     VTKM_STATIC_ASSERT_MSG(index >= 0, "Attempting to put invalid type into a Variant");
 
-    new (this->GetPointer()) T(src);
     this->Index = index;
+    new (&this->Get<index>()) T(src);
   }
 
   template <typename T>
-  VTK_M_DEVICE Variant(const T&& src) noexcept
+  VTK_M_DEVICE Variant& operator=(const T& src)
   {
-    constexpr vtkm::IdComponent index = IndexOf<T>::value;
-    // Might be a way to use an enable_if to enforce a proper type.
-    VTKM_STATIC_ASSERT_MSG(index >= 0, "Attempting to put invalid type into a Variant");
-
-    new (this->GetPointer()) T(std::move(src));
-    this->Index = index;
+    this->Emplace<T>(src);
+    return *this;
   }
 
   template <typename T, typename... Args>
@@ -425,18 +353,16 @@ private:
   VTK_M_DEVICE T& EmplaceImpl(Args&&... args)
   {
     this->Reset();
-    T* value = new (this->GetPointer()) T{ args... };
     this->Index = I;
-    return *value;
+    return *(new (&this->Get<I>()) T{ args... });
   }
 
   template <typename T, vtkm::IdComponent I, typename U, typename... Args>
   VTK_M_DEVICE T& EmplaceImpl(std::initializer_list<U> il, Args&&... args)
   {
     this->Reset();
-    T* value = new (this->GetPointer()) T(il, args...);
     this->Index = I;
-    return *value;
+    return *(new (&this->Get<I>()) T(il, args...));
   }
 
 public:
@@ -448,14 +374,14 @@ public:
   VTK_M_DEVICE TypeAt<I>& Get() noexcept
   {
     VTKM_ASSERT(I == this->GetIndex());
-    return *reinterpret_cast<TypeAt<I>*>(this->GetPointer());
+    return detail::VariantUnionGet<I>(this->Storage);
   }
 
   template <vtkm::IdComponent I>
   VTK_M_DEVICE const TypeAt<I>& Get() const noexcept
   {
     VTKM_ASSERT(I == this->GetIndex());
-    return *reinterpret_cast<const TypeAt<I>*>(this->GetPointer());
+    return detail::VariantUnionGet<I>(this->Storage);
   }
   //@}
 
@@ -467,14 +393,14 @@ public:
   VTK_M_DEVICE T& Get() noexcept
   {
     VTKM_ASSERT(this->GetIndexOf<T>() == this->GetIndex());
-    return *reinterpret_cast<T*>(this->GetPointer());
+    return detail::VariantUnionGet<IndexOf<T>::value>(this->Storage);
   }
 
   template <typename T>
   VTK_M_DEVICE const T& Get() const noexcept
   {
     VTKM_ASSERT(this->GetIndexOf<T>() == this->GetIndex());
-    return *reinterpret_cast<const T*>(this->GetPointer());
+    return detail::VariantUnionGet<IndexOf<T>::value>(this->Storage);
   }
   //@}
 
@@ -490,7 +416,13 @@ public:
     noexcept(noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
       -> decltype(f(std::declval<const TypeAt<0>&>(), args...))
   {
-    return this->Superclass::CastAndCall(std::forward<Functor>(f), std::forward<Args>(args)...);
+    VTKM_ASSERT(this->IsValid());
+    return detail::VariantCastAndCallImpl(
+      std::integral_constant<vtkm::IdComponent, NumberOfTypes>{},
+      this->GetIndex(),
+      std::forward<Functor>(f),
+      this->Storage,
+      std::forward<Args>(args)...);
   }
 
   template <typename Functor, typename... Args>
@@ -498,13 +430,26 @@ public:
     noexcept(f(std::declval<const TypeAt<0>&>(), args...)))
     -> decltype(f(std::declval<TypeAt<0>&>(), args...))
   {
-    return this->Superclass::CastAndCall(std::forward<Functor>(f), std::forward<Args>(args)...);
+    VTKM_ASSERT(this->IsValid());
+    return detail::VariantCastAndCallImpl(
+      std::integral_constant<vtkm::IdComponent, NumberOfTypes>{},
+      this->GetIndex(),
+      std::forward<Functor>(f),
+      this->Storage,
+      std::forward<Args>(args)...);
   }
 
   /// Destroys any object the Variant is holding and sets the Variant to an invalid state. This
   /// method is not thread safe.
   ///
-  VTK_M_DEVICE void Reset() noexcept { this->Superclass::Reset(); }
+  VTK_M_DEVICE void Reset() noexcept
+  {
+    if (this->IsValid())
+    {
+      this->CastAndCall(detail::VariantDestroyFunctor{});
+      this->Index = -1;
+    }
+  }
 };
 
 /// \brief Convert a ListTag to a Variant.
diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index 4211ff916..a2efcde54 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -19,7 +19,9 @@
 
 #include <vtkm/Types.h>
 
-#include <vtkm/internal/brigand.hpp>
+#include <vtkm/internal/Assume.h>
+
+#include <vtkmstd/is_trivial.h>
 
 #include <type_traits>
 
@@ -45,2136 +47,2845 @@ struct VariantDummyReturn<void>
   VTK_M_DEVICE static inline void F() noexcept {}
 };
 
-template <typename ReturnType, typename Functor, typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(brigand::list<>,
-                                                      vtkm::IdComponent,
-                                                      Functor&&,
-                                                      const void*,
-                                                      Args&&...) noexcept
-{
-  // If we are here, it means we failed to find the appropriate type in a variant
-  VTKM_ASSERT(false && "Internal error, bad Variant state.");
-  return VariantDummyReturn<ReturnType>::F();
-}
-
 // clang-format off
 
-template <typename ReturnType,
-          typename T0,
-          typename Functor,
+// --------------------------------------------------------------------------------
+// Helper classes to determine if all Variant types are trivial.
+template <typename... Ts>
+struct AllTriviallyCopyable;
+
+template <typename T0>
+struct AllTriviallyCopyable<T0>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  true)> { };
+template <typename T0, typename T1>
+struct AllTriviallyCopyable<T0, T1>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2>
+struct AllTriviallyCopyable<T0, T1, T2>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3>
+struct AllTriviallyCopyable<T0, T1, T2, T3>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  vtkmstd::is_trivially_copyable<T16>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  vtkmstd::is_trivially_copyable<T16>::value &&
+                                  vtkmstd::is_trivially_copyable<T17>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  vtkmstd::is_trivially_copyable<T16>::value &&
+                                  vtkmstd::is_trivially_copyable<T17>::value &&
+                                  vtkmstd::is_trivially_copyable<T18>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  vtkmstd::is_trivially_copyable<T16>::value &&
+                                  vtkmstd::is_trivially_copyable<T17>::value &&
+                                  vtkmstd::is_trivially_copyable<T18>::value &&
+                                  vtkmstd::is_trivially_copyable<T19>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+                                  vtkmstd::is_trivially_copyable<T1>::value &&
+                                  vtkmstd::is_trivially_copyable<T2>::value &&
+                                  vtkmstd::is_trivially_copyable<T3>::value &&
+                                  vtkmstd::is_trivially_copyable<T4>::value &&
+                                  vtkmstd::is_trivially_copyable<T5>::value &&
+                                  vtkmstd::is_trivially_copyable<T6>::value &&
+                                  vtkmstd::is_trivially_copyable<T7>::value &&
+                                  vtkmstd::is_trivially_copyable<T8>::value &&
+                                  vtkmstd::is_trivially_copyable<T9>::value &&
+                                  vtkmstd::is_trivially_copyable<T10>::value &&
+                                  vtkmstd::is_trivially_copyable<T11>::value &&
+                                  vtkmstd::is_trivially_copyable<T12>::value &&
+                                  vtkmstd::is_trivially_copyable<T13>::value &&
+                                  vtkmstd::is_trivially_copyable<T14>::value &&
+                                  vtkmstd::is_trivially_copyable<T15>::value &&
+                                  vtkmstd::is_trivially_copyable<T16>::value &&
+                                  vtkmstd::is_trivially_copyable<T17>::value &&
+                                  vtkmstd::is_trivially_copyable<T18>::value &&
+                                  vtkmstd::is_trivially_copyable<T19>::value &&
+                                  AllTriviallyCopyable<T20, Ts...>::value)> { };
+
+template <typename... Ts>
+struct AllTriviallyConstructible;
+
+template <typename T0>
+struct AllTriviallyConstructible<T0>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  true)> { };
+template <typename T0, typename T1>
+struct AllTriviallyConstructible<T0, T1>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2>
+struct AllTriviallyConstructible<T0, T1, T2>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3>
+struct AllTriviallyConstructible<T0, T1, T2, T3>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  vtkmstd::is_trivially_constructible<T16>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  vtkmstd::is_trivially_constructible<T16>::value &&
+                                  vtkmstd::is_trivially_constructible<T17>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  vtkmstd::is_trivially_constructible<T16>::value &&
+                                  vtkmstd::is_trivially_constructible<T17>::value &&
+                                  vtkmstd::is_trivially_constructible<T18>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  vtkmstd::is_trivially_constructible<T16>::value &&
+                                  vtkmstd::is_trivially_constructible<T17>::value &&
+                                  vtkmstd::is_trivially_constructible<T18>::value &&
+                                  vtkmstd::is_trivially_constructible<T19>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+                                  vtkmstd::is_trivially_constructible<T1>::value &&
+                                  vtkmstd::is_trivially_constructible<T2>::value &&
+                                  vtkmstd::is_trivially_constructible<T3>::value &&
+                                  vtkmstd::is_trivially_constructible<T4>::value &&
+                                  vtkmstd::is_trivially_constructible<T5>::value &&
+                                  vtkmstd::is_trivially_constructible<T6>::value &&
+                                  vtkmstd::is_trivially_constructible<T7>::value &&
+                                  vtkmstd::is_trivially_constructible<T8>::value &&
+                                  vtkmstd::is_trivially_constructible<T9>::value &&
+                                  vtkmstd::is_trivially_constructible<T10>::value &&
+                                  vtkmstd::is_trivially_constructible<T11>::value &&
+                                  vtkmstd::is_trivially_constructible<T12>::value &&
+                                  vtkmstd::is_trivially_constructible<T13>::value &&
+                                  vtkmstd::is_trivially_constructible<T14>::value &&
+                                  vtkmstd::is_trivially_constructible<T15>::value &&
+                                  vtkmstd::is_trivially_constructible<T16>::value &&
+                                  vtkmstd::is_trivially_constructible<T17>::value &&
+                                  vtkmstd::is_trivially_constructible<T18>::value &&
+                                  vtkmstd::is_trivially_constructible<T19>::value &&
+                                  AllTriviallyConstructible<T20, Ts...>::value)> { };
+
+template <typename... Ts>
+struct AllTriviallyDestructible;
+
+template <typename T0>
+struct AllTriviallyDestructible<T0>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  true)> { };
+template <typename T0, typename T1>
+struct AllTriviallyDestructible<T0, T1>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2>
+struct AllTriviallyDestructible<T0, T1, T2>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3>
+struct AllTriviallyDestructible<T0, T1, T2, T3>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  vtkmstd::is_trivially_destructible<T16>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  vtkmstd::is_trivially_destructible<T16>::value &&
+                                  vtkmstd::is_trivially_destructible<T17>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  vtkmstd::is_trivially_destructible<T16>::value &&
+                                  vtkmstd::is_trivially_destructible<T17>::value &&
+                                  vtkmstd::is_trivially_destructible<T18>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  vtkmstd::is_trivially_destructible<T16>::value &&
+                                  vtkmstd::is_trivially_destructible<T17>::value &&
+                                  vtkmstd::is_trivially_destructible<T18>::value &&
+                                  vtkmstd::is_trivially_destructible<T19>::value &&
+                                  true)> { };
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+                                  vtkmstd::is_trivially_destructible<T1>::value &&
+                                  vtkmstd::is_trivially_destructible<T2>::value &&
+                                  vtkmstd::is_trivially_destructible<T3>::value &&
+                                  vtkmstd::is_trivially_destructible<T4>::value &&
+                                  vtkmstd::is_trivially_destructible<T5>::value &&
+                                  vtkmstd::is_trivially_destructible<T6>::value &&
+                                  vtkmstd::is_trivially_destructible<T7>::value &&
+                                  vtkmstd::is_trivially_destructible<T8>::value &&
+                                  vtkmstd::is_trivially_destructible<T9>::value &&
+                                  vtkmstd::is_trivially_destructible<T10>::value &&
+                                  vtkmstd::is_trivially_destructible<T11>::value &&
+                                  vtkmstd::is_trivially_destructible<T12>::value &&
+                                  vtkmstd::is_trivially_destructible<T13>::value &&
+                                  vtkmstd::is_trivially_destructible<T14>::value &&
+                                  vtkmstd::is_trivially_destructible<T15>::value &&
+                                  vtkmstd::is_trivially_destructible<T16>::value &&
+                                  vtkmstd::is_trivially_destructible<T17>::value &&
+                                  vtkmstd::is_trivially_destructible<T18>::value &&
+                                  vtkmstd::is_trivially_destructible<T19>::value &&
+                                  AllTriviallyDestructible<T20, Ts...>::value)> { };
+
+// --------------------------------------------------------------------------------
+// Union type used inside of Variant
+//
+// You may be asking yourself, why not just use an std::aligned_union rather than a real union
+// type? That was our first implementation, but the problem is that the std::aligned_union
+// reference needs to be recast to the actual type. Typically you would do that with
+// reinterpret_cast. However, doing that leads to undefined behavior. The C++ compiler assumes that
+// 2 pointers of different types point to different memory (even if it is clear that they are set
+// to the same address). That means optimizers can remove code because it "knows" that data in one
+// type cannot affect data in another type. To safely change the type of an std::aligned_union,
+// you really have to do an std::memcpy. This is problematic for types that cannot be trivially
+// copied. Another problem is that we found that device compilers do not optimize the memcpy
+// as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
+//
+// Part of the trickiness of the union implementation is trying to preserve when the type is
+// trivially constructible and copyable. The trick is that if members of the union are not trivial,
+// then the default constructors are deleted. To get around that, a non-default constructor is
+// added, which we can use to construct the union for non-trivial types. Working with types with
+// non-trivial destructors are particularly trick. Again, if any member of the union has a
+// non-trivial destructor, the destructor is deleted. Unlike a constructor, you cannot just say to
+// use a different destructor. Thus, we have to define our own destructor for the union.
+// Technically, the destructor here does not do anything, but the actual destruction should be
+// handled by the Variant class that contains this VariantUnion. We actually need two separate
+// implementations of our union, one that defines a destructor and one that use the default
+// destructor. If you define your own destructor, you can lose the trivial constructor and trivial
+// copy properties.
+//
+
+// TD = trivially deconstructible
+template <typename... Ts>
+union VariantUnionTD;
+
+// NTD = non-trivially deconstructible
+template <typename... Ts>
+union VariantUnionNTD;
+
+template <typename T0>
+union VariantUnionTD<T0>
+{
+  T0 V0;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0>
+union VariantUnionNTD<T0>
+{
+  T0 V0;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1>
+union VariantUnionTD<T0, T1>
+{
+  T0 V0;
+  T1 V1;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1>
+union VariantUnionNTD<T0, T1>
+{
+  T0 V0;
+  T1 V1;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2>
+union VariantUnionTD<T0, T1, T2>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2>
+union VariantUnionNTD<T0, T1, T2>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3>
+union VariantUnionTD<T0, T1, T2, T3>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3>
+union VariantUnionNTD<T0, T1, T2, T3>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+union VariantUnionTD<T0, T1, T2, T3, T4>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+union VariantUnionNTD<T0, T1, T2, T3, T4>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  T19 V19;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+{
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  T19 V19;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+{
+  vtkm::internal::NullType Dummy;
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  T19 V19;
+  VariantUnionTD<T20, Ts...> Remaining;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+{
+  vtkm::internal::NullType Dummy;
+  T0 V0;
+  T1 V1;
+  T2 V2;
+  T3 V3;
+  T4 V4;
+  T5 V5;
+  T6 V6;
+  T7 V7;
+  T8 V8;
+  T9 V9;
+  T10 V10;
+  T11 V11;
+  T12 V12;
+  T13 V13;
+  T14 V14;
+  T15 V15;
+  T16 V16;
+  T17 V17;
+  T18 V18;
+  T19 V19;
+  VariantUnionNTD<T20, Ts...> Remaining;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <bool TrivialConstructor, typename... Ts>
+struct VariantUnionFinder;
+
+template <typename... Ts>
+struct VariantUnionFinder<true, Ts...>
+{
+  using type = VariantUnionTD<Ts...>;
+};
+template <typename... Ts>
+struct VariantUnionFinder<false, Ts...>
+{
+  using type = VariantUnionNTD<Ts...>;
+};
+
+template <typename... Ts>
+using VariantUnion =
+  typename VariantUnionFinder<AllTriviallyDestructible<Ts...>::value, Ts...>::type;
+
+// --------------------------------------------------------------------------------
+// Methods to get values out of the variant union
+template <vtkm::IdComponent I, typename UnionType>
+struct VariantUnionGetImpl;
+
+template <typename UnionType>
+struct VariantUnionGetImpl<0, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V0)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V0;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<1, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V1)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V1;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<2, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V2)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V2;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<3, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V3)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V3;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<4, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V4)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V4;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<5, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V5)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V5;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<6, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V6)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V6;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<7, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V7)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V7;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<8, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V8)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V8;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<9, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V9)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V9;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<10, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V10)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V10;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<11, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V11)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V11;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<12, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V12)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V12;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<13, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V13)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V13;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<14, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V14)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V14;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<15, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V15)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V15;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<16, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V16)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V16;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<17, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V17)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V17;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<18, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V18)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V18;
+  }
+};
+
+template <typename UnionType>
+struct VariantUnionGetImpl<19, UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V19)&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V19;
+  }
+};
+
+
+template <vtkm::IdComponent I, typename UnionType>
+struct VariantUnionGetImpl
+{
+  VTKM_STATIC_ASSERT(I >= 20);
+  using RecursiveGet = VariantUnionGetImpl<I - 20, decltype(std::declval<UnionType>().Remaining)>;
+  using ReturnType = typename RecursiveGet::ReturnType;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return RecursiveGet::Get(storage.Remaining);
+  }
+};
+
+template <vtkm::IdComponent I, typename UnionType>
+VTK_M_DEVICE typename VariantUnionGetImpl<I, UnionType>::ReturnType
+VariantUnionGet(UnionType& storage) noexcept
+{
+  return VariantUnionGetImpl<I, UnionType>::Get(storage);
+}
+
+// --------------------------------------------------------------------------------
+// Internal implementation of CastAndCall for Variant
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 1>,
   vtkm::IdComponent index,
   Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 2>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 3>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 4>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 5>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 6>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 7>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 8>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 9>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 10>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 11>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 12>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 13>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 14>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 15>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 16>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     case 15:
-      return f(*reinterpret_cast<const T15*>(storage), std::forward<Args>(args)...);
+      return f(storage.V15, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 17>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     case 15:
-      return f(*reinterpret_cast<T15*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
-    case 15:
-      return f(*reinterpret_cast<const T15*>(storage), std::forward<Args>(args)...);
+      return f(storage.V15, std::forward<Args>(args)...);
     case 16:
-      return f(*reinterpret_cast<const T16*>(storage), std::forward<Args>(args)...);
+      return f(storage.V16, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 18>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     case 15:
-      return f(*reinterpret_cast<T15*>(storage), std::forward<Args>(args)...);
+      return f(storage.V15, std::forward<Args>(args)...);
     case 16:
-      return f(*reinterpret_cast<T16*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
-    case 15:
-      return f(*reinterpret_cast<const T15*>(storage), std::forward<Args>(args)...);
-    case 16:
-      return f(*reinterpret_cast<const T16*>(storage), std::forward<Args>(args)...);
+      return f(storage.V16, std::forward<Args>(args)...);
     case 17:
-      return f(*reinterpret_cast<const T17*>(storage), std::forward<Args>(args)...);
+      return f(storage.V17, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 19>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     case 15:
-      return f(*reinterpret_cast<T15*>(storage), std::forward<Args>(args)...);
+      return f(storage.V15, std::forward<Args>(args)...);
     case 16:
-      return f(*reinterpret_cast<T16*>(storage), std::forward<Args>(args)...);
+      return f(storage.V16, std::forward<Args>(args)...);
     case 17:
-      return f(*reinterpret_cast<T17*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
-    case 15:
-      return f(*reinterpret_cast<const T15*>(storage), std::forward<Args>(args)...);
-    case 16:
-      return f(*reinterpret_cast<const T16*>(storage), std::forward<Args>(args)...);
-    case 17:
-      return f(*reinterpret_cast<const T17*>(storage), std::forward<Args>(args)...);
+      return f(storage.V17, std::forward<Args>(args)...);
     case 18:
-      return f(*reinterpret_cast<const T18*>(storage), std::forward<Args>(args)...);
+      return f(storage.V18, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename Functor,
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, 20>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
     case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
+      return f(storage.V0, std::forward<Args>(args)...);
     case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
+      return f(storage.V1, std::forward<Args>(args)...);
     case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
+      return f(storage.V2, std::forward<Args>(args)...);
     case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
+      return f(storage.V3, std::forward<Args>(args)...);
     case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
+      return f(storage.V4, std::forward<Args>(args)...);
     case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
+      return f(storage.V5, std::forward<Args>(args)...);
     case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
+      return f(storage.V6, std::forward<Args>(args)...);
     case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
+      return f(storage.V7, std::forward<Args>(args)...);
     case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
+      return f(storage.V8, std::forward<Args>(args)...);
     case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
+      return f(storage.V9, std::forward<Args>(args)...);
     case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
+      return f(storage.V10, std::forward<Args>(args)...);
     case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
+      return f(storage.V11, std::forward<Args>(args)...);
     case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
+      return f(storage.V12, std::forward<Args>(args)...);
     case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
+      return f(storage.V13, std::forward<Args>(args)...);
     case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
+      return f(storage.V14, std::forward<Args>(args)...);
     case 15:
-      return f(*reinterpret_cast<T15*>(storage), std::forward<Args>(args)...);
+      return f(storage.V15, std::forward<Args>(args)...);
     case 16:
-      return f(*reinterpret_cast<T16*>(storage), std::forward<Args>(args)...);
+      return f(storage.V16, std::forward<Args>(args)...);
     case 17:
-      return f(*reinterpret_cast<T17*>(storage), std::forward<Args>(args)...);
+      return f(storage.V17, std::forward<Args>(args)...);
     case 18:
-      return f(*reinterpret_cast<T18*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename T19,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<const T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<const T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<const T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<const T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<const T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<const T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<const T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<const T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<const T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<const T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<const T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<const T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<const T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<const T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<const T14*>(storage), std::forward<Args>(args)...);
-    case 15:
-      return f(*reinterpret_cast<const T15*>(storage), std::forward<Args>(args)...);
-    case 16:
-      return f(*reinterpret_cast<const T16*>(storage), std::forward<Args>(args)...);
-    case 17:
-      return f(*reinterpret_cast<const T17*>(storage), std::forward<Args>(args)...);
-    case 18:
-      return f(*reinterpret_cast<const T18*>(storage), std::forward<Args>(args)...);
+      return f(storage.V18, std::forward<Args>(args)...);
     case 19:
-      return f(*reinterpret_cast<const T19*>(storage), std::forward<Args>(args)...);
+      return f(storage.V19, std::forward<Args>(args)...);
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename T19,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  switch (index)
-  {
-    case 0:
-      return f(*reinterpret_cast<T0*>(storage), std::forward<Args>(args)...);
-    case 1:
-      return f(*reinterpret_cast<T1*>(storage), std::forward<Args>(args)...);
-    case 2:
-      return f(*reinterpret_cast<T2*>(storage), std::forward<Args>(args)...);
-    case 3:
-      return f(*reinterpret_cast<T3*>(storage), std::forward<Args>(args)...);
-    case 4:
-      return f(*reinterpret_cast<T4*>(storage), std::forward<Args>(args)...);
-    case 5:
-      return f(*reinterpret_cast<T5*>(storage), std::forward<Args>(args)...);
-    case 6:
-      return f(*reinterpret_cast<T6*>(storage), std::forward<Args>(args)...);
-    case 7:
-      return f(*reinterpret_cast<T7*>(storage), std::forward<Args>(args)...);
-    case 8:
-      return f(*reinterpret_cast<T8*>(storage), std::forward<Args>(args)...);
-    case 9:
-      return f(*reinterpret_cast<T9*>(storage), std::forward<Args>(args)...);
-    case 10:
-      return f(*reinterpret_cast<T10*>(storage), std::forward<Args>(args)...);
-    case 11:
-      return f(*reinterpret_cast<T11*>(storage), std::forward<Args>(args)...);
-    case 12:
-      return f(*reinterpret_cast<T12*>(storage), std::forward<Args>(args)...);
-    case 13:
-      return f(*reinterpret_cast<T13*>(storage), std::forward<Args>(args)...);
-    case 14:
-      return f(*reinterpret_cast<T14*>(storage), std::forward<Args>(args)...);
-    case 15:
-      return f(*reinterpret_cast<T15*>(storage), std::forward<Args>(args)...);
-    case 16:
-      return f(*reinterpret_cast<T16*>(storage), std::forward<Args>(args)...);
-    case 17:
-      return f(*reinterpret_cast<T17*>(storage), std::forward<Args>(args)...);
-    case 18:
-      return f(*reinterpret_cast<T18*>(storage), std::forward<Args>(args)...);
-    case 19:
-      return f(*reinterpret_cast<T19*>(storage), std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
 //clang-format on
 
 // Recurse for cases where Variant has more than 20 types
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename T19,
-          typename T20,
-          typename... RemainingT,
+template <vtkm::IdComponent N,
           typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, RemainingT...>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, N>,
   vtkm::IdComponent index,
   Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
-  if (index < 20)
+  switch (index)
   {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>{},
-      index,
-      f,
-      storage,
-      args...);
-  }
-  else
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T20, RemainingT...>{}, index - 20, f, storage, args...);
-  }
-}
-
-template <typename ReturnType,
-          typename T0,
-          typename T1,
-          typename T2,
-          typename T3,
-          typename T4,
-          typename T5,
-          typename T6,
-          typename T7,
-          typename T8,
-          typename T9,
-          typename T10,
-          typename T11,
-          typename T12,
-          typename T13,
-          typename T14,
-          typename T15,
-          typename T16,
-          typename T17,
-          typename T18,
-          typename T19,
-          typename T20,
-          typename... RemainingT,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, RemainingT...>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  if (index < 20)
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>{},
-      index,
-      f,
-      storage,
-      args...);
-  }
-  else
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T20, RemainingT...>{}, index - 20, f, storage, args...);
+    case 0:
+      return f(storage.V0, std::forward<Args>(args)...);
+    case 1:
+      return f(storage.V1, std::forward<Args>(args)...);
+    case 2:
+      return f(storage.V2, std::forward<Args>(args)...);
+    case 3:
+      return f(storage.V3, std::forward<Args>(args)...);
+    case 4:
+      return f(storage.V4, std::forward<Args>(args)...);
+    case 5:
+      return f(storage.V5, std::forward<Args>(args)...);
+    case 6:
+      return f(storage.V6, std::forward<Args>(args)...);
+    case 7:
+      return f(storage.V7, std::forward<Args>(args)...);
+    case 8:
+      return f(storage.V8, std::forward<Args>(args)...);
+    case 9:
+      return f(storage.V9, std::forward<Args>(args)...);
+    case 10:
+      return f(storage.V10, std::forward<Args>(args)...);
+    case 11:
+      return f(storage.V11, std::forward<Args>(args)...);
+    case 12:
+      return f(storage.V12, std::forward<Args>(args)...);
+    case 13:
+      return f(storage.V13, std::forward<Args>(args)...);
+    case 14:
+      return f(storage.V14, std::forward<Args>(args)...);
+    case 15:
+      return f(storage.V15, std::forward<Args>(args)...);
+    case 16:
+      return f(storage.V16, std::forward<Args>(args)...);
+    case 17:
+      return f(storage.V17, std::forward<Args>(args)...);
+    case 18:
+      return f(storage.V18, std::forward<Args>(args)...);
+    case 19:
+      return f(storage.V19, std::forward<Args>(args)...);
+    default:
+      return VariantCastAndCallImpl(std::integral_constant<vtkm::IdComponent, N - 20>{},
+                                    index - 20,
+                                    std::forward<Functor>(f),
+                                    storage.Remaining,
+                                    std::forward<Args>(args)...);
   }
 }
 
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index 0801dc812..d116558ce 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -31,7 +31,9 @@ $# Ignore the following comment. It is meant for the generated file.
 
 #include <vtkm/Types.h>
 
-#include <vtkm/internal/brigand.hpp>
+#include <vtkm/internal/Assume.h>
+
+#include <vtkmstd/is_trivial.h>
 
 #include <type_traits>
 
@@ -46,9 +48,17 @@ def type_list(num_params):
   for param in range(1, num_params + 1):
     result += ', T%d' % param
   return result
+
+def typename_list(num_params):
+  if num_params < 0:
+    return ''
+  result = 'typename T0'
+  for param in range(1, num_params + 1):
+    result += ', typename T%d' % param
+  return result
 )\
 $#
-$extend(type_list)\
+$extend(type_list, typename_list)\
 
 namespace vtkm
 {
@@ -70,70 +80,234 @@ struct VariantDummyReturn<void>
   VTK_M_DEVICE static inline void F() noexcept {}
 };
 
-template <typename ReturnType, typename Functor, typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(brigand::list<>,
-                                                      vtkm::IdComponent,
-                                                      Functor&&,
-                                                      const void*,
-                                                      Args&&...) noexcept
-{
-  // If we are here, it means we failed to find the appropriate type in a variant
-  VTKM_ASSERT(false && "Internal error, bad Variant state.");
-  return VariantDummyReturn<ReturnType>::F();
-}
-
 // clang-format off
 
-$for(num_params in range(0, max_expanded))\
-template <typename ReturnType,
-$for(param_index in range(0, num_params + 1))\
-          typename T$(param_index),
+// --------------------------------------------------------------------------------
+// Helper classes to determine if all Variant types are trivial.
+template <typename... Ts>
+struct AllTriviallyCopyable;
+
+$for(num_params in range(max_expanded))\
+template <$typename_list(num_params)>
+struct AllTriviallyCopyable<$type_list(num_params)>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+$for(param_index in range(1, num_params + 1))\
+                                  vtkmstd::is_trivially_copyable<T$(param_index)>::value &&
 $endfor\
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<$type_list(num_params)>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+                                  true)> { };
+$endfor\
+template <$typename_list(max_expanded), typename... Ts>
+struct AllTriviallyCopyable<$type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
+$for(param_index in range(1, max_expanded))\
+                                  vtkmstd::is_trivially_copyable<T$(param_index)>::value &&
+$endfor\
+                                  AllTriviallyCopyable<T$(max_expanded), Ts...>::value)> { };
+
+template <typename... Ts>
+struct AllTriviallyConstructible;
+
+$for(num_params in range(max_expanded))\
+template <$typename_list(num_params)>
+struct AllTriviallyConstructible<$type_list(num_params)>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+$for(param_index in range(1, num_params + 1))\
+                                  vtkmstd::is_trivially_constructible<T$(param_index)>::value &&
+$endfor\
+                                  true)> { };
+$endfor\
+template <$typename_list(max_expanded), typename... Ts>
+struct AllTriviallyConstructible<$type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
+$for(param_index in range(1, max_expanded))\
+                                  vtkmstd::is_trivially_constructible<T$(param_index)>::value &&
+$endfor\
+                                  AllTriviallyConstructible<T$(max_expanded), Ts...>::value)> { };
+
+template <typename... Ts>
+struct AllTriviallyDestructible;
+
+$for(num_params in range(max_expanded))\
+template <$typename_list(num_params)>
+struct AllTriviallyDestructible<$type_list(num_params)>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+$for(param_index in range(1, num_params + 1))\
+                                  vtkmstd::is_trivially_destructible<T$(param_index)>::value &&
+$endfor\
+                                  true)> { };
+$endfor\
+template <$typename_list(max_expanded), typename... Ts>
+struct AllTriviallyDestructible<$type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
+$for(param_index in range(1, max_expanded))\
+                                  vtkmstd::is_trivially_destructible<T$(param_index)>::value &&
+$endfor\
+                                  AllTriviallyDestructible<T$(max_expanded), Ts...>::value)> { };
+
+// --------------------------------------------------------------------------------
+// Union type used inside of Variant
+//
+// You may be asking yourself, why not just use an std::aligned_union rather than a real union
+// type? That was our first implementation, but the problem is that the std::aligned_union
+// reference needs to be recast to the actual type. Typically you would do that with
+// reinterpret_cast. However, doing that leads to undefined behavior. The C++ compiler assumes that
+// 2 pointers of different types point to different memory (even if it is clear that they are set
+// to the same address). That means optimizers can remove code because it "knows" that data in one
+// type cannot affect data in another type. To safely change the type of an std::aligned_union,
+// you really have to do an std::memcpy. This is problematic for types that cannot be trivially
+// copied. Another problem is that we found that device compilers do not optimize the memcpy
+// as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
+//
+// Part of the trickiness of the union implementation is trying to preserve when the type is
+// trivially constructible and copyable. The trick is that if members of the union are not trivial,
+// then the default constructors are deleted. To get around that, a non-default constructor is
+// added, which we can use to construct the union for non-trivial types. Working with types with
+// non-trivial destructors are particularly trick. Again, if any member of the union has a
+// non-trivial destructor, the destructor is deleted. Unlike a constructor, you cannot just say to
+// use a different destructor. Thus, we have to define our own destructor for the union.
+// Technically, the destructor here does not do anything, but the actual destruction should be
+// handled by the Variant class that contains this VariantUnion. We actually need two separate
+// implementations of our union, one that defines a destructor and one that use the default
+// destructor. If you define your own destructor, you can lose the trivial constructor and trivial
+// copy properties.
+//
+
+// TD = trivially deconstructible
+template <typename... Ts>
+union VariantUnionTD;
+
+// NTD = non-trivially deconstructible
+template <typename... Ts>
+union VariantUnionNTD;
+
+$for(num_params in range(max_expanded))\
+template <$typename_list(num_params)>
+union VariantUnionTD<$type_list(num_params)>
 {
-  switch (index)
-  {
-$for(param_index in range(0, num_params + 1))\
-    case $(param_index):
-      return f(*reinterpret_cast<const T$(param_index)*>(storage), std::forward<Args>(args)...);
+$for(param_index in range(num_params + 1))\
+  T$(param_index) V$(param_index);
 $endfor\
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <$typename_list(num_params)>
+union VariantUnionNTD<$type_list(num_params)>
+{
+$for(param_index in range(num_params + 1))\
+  T$(param_index) V$(param_index);
+$endfor\
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+$endfor\
+
+template <$typename_list(max_expanded), typename... Ts>
+union VariantUnionTD<$type_list(max_expanded), Ts...>
+{
+  vtkm::internal::NullType Dummy;
+$for(param_index in range(max_expanded))\
+  T$(param_index) V$(param_index);
+$endfor\
+  VariantUnionTD<T$(max_expanded), Ts...> Remaining;
+  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
+  VariantUnionTD() = default;
+};
+
+template <$typename_list(max_expanded), typename... Ts>
+union VariantUnionNTD<$type_list(max_expanded), Ts...>
+{
+  vtkm::internal::NullType Dummy;
+$for(param_index in range(max_expanded))\
+  T$(param_index) V$(param_index);
+$endfor\
+  VariantUnionNTD<T$(max_expanded), Ts...> Remaining;
+  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
+  VariantUnionNTD() = default;
+  VTK_M_DEVICE ~VariantUnionNTD() { }
+};
+
+template <bool TrivialConstructor, typename... Ts>
+struct VariantUnionFinder;
+
+template <typename... Ts>
+struct VariantUnionFinder<true, Ts...>
+{
+  using type = VariantUnionTD<Ts...>;
+};
+template <typename... Ts>
+struct VariantUnionFinder<false, Ts...>
+{
+  using type = VariantUnionNTD<Ts...>;
+};
+
+template <typename... Ts>
+using VariantUnion =
+  typename VariantUnionFinder<AllTriviallyDestructible<Ts...>::value, Ts...>::type;
+
+// --------------------------------------------------------------------------------
+// Methods to get values out of the variant union
+template <vtkm::IdComponent I, typename UnionType>
+struct VariantUnionGetImpl;
+
+$for(param_index in range(max_expanded))\
+template <typename UnionType>
+struct VariantUnionGetImpl<$(param_index), UnionType>
+{
+  using ReturnType = decltype(std::declval<UnionType>().V$(param_index))&;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return storage.V$(param_index);
   }
+};
+
+$endfor\
+
+template <vtkm::IdComponent I, typename UnionType>
+struct VariantUnionGetImpl
+{
+  VTKM_STATIC_ASSERT(I >= $(max_expanded));
+  using RecursiveGet = VariantUnionGetImpl<I - $(max_expanded), decltype(std::declval<UnionType>().Remaining)>;
+  using ReturnType = typename RecursiveGet::ReturnType;
+  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  {
+    return RecursiveGet::Get(storage.Remaining);
+  }
+};
+
+template <vtkm::IdComponent I, typename UnionType>
+VTK_M_DEVICE typename VariantUnionGetImpl<I, UnionType>::ReturnType
+VariantUnionGet(UnionType& storage) noexcept
+{
+  return VariantUnionGetImpl<I, UnionType>::Get(storage);
 }
 
-template <typename ReturnType,
-$for(param_index in range(0, num_params + 1))\
-          typename T$(param_index),
-$endfor\
-          typename Functor,
+// --------------------------------------------------------------------------------
+// Internal implementation of CastAndCall for Variant
+$for(num_params in range(max_expanded))\
+template <typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<$type_list(num_params)>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, $(num_params + 1)>,
   vtkm::IdComponent index,
   Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
-$for(param_index in range(0, num_params + 1))\
+$for(param_index in range(num_params + 1))\
     case $(param_index):
-      return f(*reinterpret_cast<T$(param_index)*>(storage), std::forward<Args>(args)...);
+      return f(storage.V$(param_index), std::forward<Args>(args)...);
 $endfor\
     default:
       // If we are here, it means we failed to find the appropriate type in a variant
       VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<ReturnType>::F();
+      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
   }
 }
 
@@ -141,63 +315,30 @@ $endfor\
 //clang-format on
 
 // Recurse for cases where Variant has more than $(max_expanded) types
-template <typename ReturnType,
-$for(param_index in range(0, max_expanded + 1))\
-          typename T$(param_index),
-$endfor\
-          typename... RemainingT,
+template <vtkm::IdComponent N,
           typename Functor,
+          typename UnionType,
           typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<$type_list(max_expanded), RemainingT...>,
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  std::integral_constant<vtkm::IdComponent, N>,
   vtkm::IdComponent index,
   Functor&& f,
-  const void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
 {
-  if (index < $(max_expanded))
+  switch (index)
   {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<$type_list(max_expanded - 1)>{},
-      index,
-      f,
-      storage,
-      args...);
-  }
-  else
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T$(max_expanded), RemainingT...>{}, index - $(max_expanded), f, storage, args...);
-  }
-}
-
-template <typename ReturnType,
-$for(param_index in range(0, max_expanded + 1))\
-          typename T$(param_index),
+$for(param_index in range(max_expanded))\
+    case $(param_index):
+      return f(storage.V$(param_index), std::forward<Args>(args)...);
 $endfor\
-          typename... RemainingT,
-          typename Functor,
-          typename... Args>
-VTK_M_DEVICE inline ReturnType VariantCastAndCallImpl(
-  brigand::list<$type_list(max_expanded), RemainingT...>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  void* storage,
-  Args&&... args) noexcept(noexcept(f(std::declval<const T0&>(), args...)))
-{
-  if (index < $(max_expanded))
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<$type_list(max_expanded - 1)>{},
-      index,
-      f,
-      storage,
-      args...);
-  }
-  else
-  {
-    return VariantCastAndCallImpl<ReturnType>(
-      brigand::list<T$(max_expanded), RemainingT...>{}, index - $(max_expanded), f, storage, args...);
+    default:
+      return VariantCastAndCallImpl(std::integral_constant<vtkm::IdComponent, N - $(max_expanded)>{},
+                                    index - $(max_expanded),
+                                    std::forward<Functor>(f),
+                                    storage.Remaining,
+                                    std::forward<Args>(args)...);
   }
 }
 

From cb60401a63a7be8394aa8f995ce0414eaeaf2d6f Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 23 Mar 2021 13:30:55 -0600
Subject: [PATCH 02/11] Use specialized class instead of function overload for
 Variant::Get

Nvcc was having troubles resolving the return type of the overloaded
function to get a value out of a `VariantUnion`. Replace the
implementation with a class with specializations. This is more verbose,
but easier on the compiler.
---
 vtkm/internal/VariantImplDetail.h    | 174 ++++++++++++++++++++-------
 vtkm/internal/VariantImplDetail.h.in |  22 ++--
 2 files changed, 144 insertions(+), 52 deletions(-)

diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index a2efcde54..993d8469c 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -1784,8 +1784,12 @@ struct VariantUnionGetImpl;
 template <typename UnionType>
 struct VariantUnionGetImpl<0, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V0)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V0);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V0;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V0;
   }
@@ -1794,8 +1798,12 @@ struct VariantUnionGetImpl<0, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<1, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V1)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V1);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V1;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V1;
   }
@@ -1804,8 +1812,12 @@ struct VariantUnionGetImpl<1, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<2, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V2)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V2);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V2;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V2;
   }
@@ -1814,8 +1826,12 @@ struct VariantUnionGetImpl<2, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<3, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V3)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V3);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V3;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V3;
   }
@@ -1824,8 +1840,12 @@ struct VariantUnionGetImpl<3, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<4, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V4)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V4);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V4;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V4;
   }
@@ -1834,8 +1854,12 @@ struct VariantUnionGetImpl<4, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<5, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V5)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V5);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V5;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V5;
   }
@@ -1844,8 +1868,12 @@ struct VariantUnionGetImpl<5, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<6, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V6)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V6);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V6;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V6;
   }
@@ -1854,8 +1882,12 @@ struct VariantUnionGetImpl<6, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<7, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V7)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V7);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V7;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V7;
   }
@@ -1864,8 +1896,12 @@ struct VariantUnionGetImpl<7, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<8, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V8)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V8);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V8;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V8;
   }
@@ -1874,8 +1910,12 @@ struct VariantUnionGetImpl<8, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<9, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V9)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V9);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V9;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V9;
   }
@@ -1884,8 +1924,12 @@ struct VariantUnionGetImpl<9, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<10, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V10)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V10);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V10;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V10;
   }
@@ -1894,8 +1938,12 @@ struct VariantUnionGetImpl<10, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<11, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V11)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V11);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V11;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V11;
   }
@@ -1904,8 +1952,12 @@ struct VariantUnionGetImpl<11, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<12, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V12)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V12);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V12;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V12;
   }
@@ -1914,8 +1966,12 @@ struct VariantUnionGetImpl<12, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<13, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V13)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V13);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V13;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V13;
   }
@@ -1924,8 +1980,12 @@ struct VariantUnionGetImpl<13, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<14, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V14)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V14);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V14;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V14;
   }
@@ -1934,8 +1994,12 @@ struct VariantUnionGetImpl<14, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<15, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V15)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V15);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V15;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V15;
   }
@@ -1944,8 +2008,12 @@ struct VariantUnionGetImpl<15, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<16, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V16)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V16);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V16;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V16;
   }
@@ -1954,8 +2022,12 @@ struct VariantUnionGetImpl<16, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<17, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V17)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V17);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V17;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V17;
   }
@@ -1964,8 +2036,12 @@ struct VariantUnionGetImpl<17, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<18, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V18)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V18);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V18;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V18;
   }
@@ -1974,8 +2050,12 @@ struct VariantUnionGetImpl<18, UnionType>
 template <typename UnionType>
 struct VariantUnionGetImpl<19, UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V19)&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V19);
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V19;
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V19;
   }
@@ -1986,19 +2066,23 @@ template <vtkm::IdComponent I, typename UnionType>
 struct VariantUnionGetImpl
 {
   VTKM_STATIC_ASSERT(I >= 20);
-  using RecursiveGet = VariantUnionGetImpl<I - 20, decltype(std::declval<UnionType>().Remaining)>;
+  using RecursiveGet = VariantUnionGetImpl<I - 20, decltype(std::declval<UnionType&>().Remaining)>;
   using ReturnType = typename RecursiveGet::ReturnType;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return RecursiveGet::Get(storage.Remaining);
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return RecursiveGet::Get(storage.Remaining);
   }
 };
 
 template <vtkm::IdComponent I, typename UnionType>
-VTK_M_DEVICE typename VariantUnionGetImpl<I, UnionType>::ReturnType
-VariantUnionGet(UnionType& storage) noexcept
+VTK_M_DEVICE auto VariantUnionGet(UnionType& storage) noexcept
+  -> decltype(VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage))&
 {
-  return VariantUnionGetImpl<I, UnionType>::Get(storage);
+  return VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage);
 }
 
 // --------------------------------------------------------------------------------
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index d116558ce..34e43465c 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -256,8 +256,12 @@ $for(param_index in range(max_expanded))\
 template <typename UnionType>
 struct VariantUnionGetImpl<$(param_index), UnionType>
 {
-  using ReturnType = decltype(std::declval<UnionType>().V$(param_index))&;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  using ReturnType = decltype(std::declval<UnionType>().V$(param_index));
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return storage.V$(param_index);
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return storage.V$(param_index);
   }
@@ -269,19 +273,23 @@ template <vtkm::IdComponent I, typename UnionType>
 struct VariantUnionGetImpl
 {
   VTKM_STATIC_ASSERT(I >= $(max_expanded));
-  using RecursiveGet = VariantUnionGetImpl<I - $(max_expanded), decltype(std::declval<UnionType>().Remaining)>;
+  using RecursiveGet = VariantUnionGetImpl<I - $(max_expanded), decltype(std::declval<UnionType&>().Remaining)>;
   using ReturnType = typename RecursiveGet::ReturnType;
-  VTK_M_DEVICE static ReturnType Get(UnionType& storage) noexcept
+  VTK_M_DEVICE static ReturnType& Get(UnionType& storage) noexcept
+  {
+    return RecursiveGet::Get(storage.Remaining);
+  }
+  VTK_M_DEVICE static const ReturnType& Get(const UnionType& storage) noexcept
   {
     return RecursiveGet::Get(storage.Remaining);
   }
 };
 
 template <vtkm::IdComponent I, typename UnionType>
-VTK_M_DEVICE typename VariantUnionGetImpl<I, UnionType>::ReturnType
-VariantUnionGet(UnionType& storage) noexcept
+VTK_M_DEVICE auto VariantUnionGet(UnionType& storage) noexcept
+  -> decltype(VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage))&
 {
-  return VariantUnionGetImpl<I, UnionType>::Get(storage);
+  return VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage);
 }
 
 // --------------------------------------------------------------------------------

From cad5dc7b711e30bc41fb98b906dccf8bfa75d5fc Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 23 Mar 2021 13:34:39 -0600
Subject: [PATCH 03/11] Avoid is_trivially_copyable on VariantUnion

For some reason some versions of the CUDA compiler would return true for
`is_trivially_copyable` on a `VariantUnion` even when the types of the
union caused the copy constructor to get deleted.

Solve the problem by using `AllTriviallyCopyable` instead of directly
caling `is_trivially_copyable` on the union.
---
 vtkm/internal/VariantImpl.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index 5e6784d14..11acef38e 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -93,7 +93,7 @@ struct VariantTriviallyCopyable;
 
 template <typename... Ts>
 struct VariantTriviallyCopyable<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>>
-  : vtkmstd::is_trivially_copyable<VariantUnion<Ts...>>
+  : AllTriviallyCopyable<Ts...>
 {
 };
 
@@ -102,7 +102,7 @@ struct VariantTriviallyConstructible;
 
 template <typename... Ts>
 struct VariantTriviallyConstructible<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>>
-  : vtkmstd::is_trivially_constructible<VariantUnion<Ts...>>
+  : AllTriviallyConstructible<Ts...>
 {
 };
 

From d2d9ba3321d59b8b2d97e0b77836b4f20e1779d5 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Mon, 22 Feb 2021 08:44:23 -0700
Subject: [PATCH 04/11] Make connectivity structures trivially copyable

It always worked to trivially copy these classes, but the compiler did
not think so because copy constructors were defined. Change these
constructors to be default so that the compler can properly check
triviality.
---
 vtkm/exec/ConnectivityPermuted.h   | 16 +++-------------
 vtkm/exec/ConnectivityStructured.h | 12 ++----------
 2 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/vtkm/exec/ConnectivityPermuted.h b/vtkm/exec/ConnectivityPermuted.h
index da47f187b..5db3c29bc 100644
--- a/vtkm/exec/ConnectivityPermuted.h
+++ b/vtkm/exec/ConnectivityPermuted.h
@@ -27,13 +27,7 @@ class ConnectivityPermutedVisitCellsWithPoints
 public:
   using SchedulingRangeType = typename OriginalConnectivity::SchedulingRangeType;
 
-  VTKM_SUPPRESS_EXEC_WARNINGS
-  VTKM_EXEC_CONT
-  ConnectivityPermutedVisitCellsWithPoints()
-    : Portal()
-    , Connectivity()
-  {
-  }
+  ConnectivityPermutedVisitCellsWithPoints() = default;
 
   VTKM_EXEC_CONT
   ConnectivityPermutedVisitCellsWithPoints(const PermutationPortal& portal,
@@ -43,12 +37,8 @@ public:
   {
   }
 
-  VTKM_EXEC_CONT
-  ConnectivityPermutedVisitCellsWithPoints(const ConnectivityPermutedVisitCellsWithPoints& src)
-    : Portal(src.Portal)
-    , Connectivity(src.Connectivity)
-  {
-  }
+  ConnectivityPermutedVisitCellsWithPoints(const ConnectivityPermutedVisitCellsWithPoints& src) =
+    default;
 
   ConnectivityPermutedVisitCellsWithPoints& operator=(
     const ConnectivityPermutedVisitCellsWithPoints& src) = default;
diff --git a/vtkm/exec/ConnectivityStructured.h b/vtkm/exec/ConnectivityStructured.h
index 65a30d925..0f14923c3 100644
--- a/vtkm/exec/ConnectivityStructured.h
+++ b/vtkm/exec/ConnectivityStructured.h
@@ -34,11 +34,7 @@ class ConnectivityStructured
 public:
   using SchedulingRangeType = typename InternalsType::SchedulingRangeType;
 
-  VTKM_EXEC_CONT
-  ConnectivityStructured()
-    : Internals()
-  {
-  }
+  ConnectivityStructured() = default;
 
   VTKM_EXEC_CONT
   ConnectivityStructured(const InternalsType& src)
@@ -46,11 +42,7 @@ public:
   {
   }
 
-  VTKM_EXEC_CONT
-  ConnectivityStructured(const ConnectivityStructured& src)
-    : Internals(src.Internals)
-  {
-  }
+  ConnectivityStructured(const ConnectivityStructured& src) = default;
 
   VTKM_EXEC_CONT
   ConnectivityStructured(

From e480fd7a24f2e39bf073bd37f1ad518be3f9e297 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Wed, 24 Mar 2021 14:41:31 -0600
Subject: [PATCH 05/11] Support copying a Variant to itself

---
 .../exec/internal/testing/UnitTestVariant.cxx | 30 +++++++---
 vtkm/internal/VariantImpl.h                   | 60 +++++++++++++++++--
 2 files changed, 77 insertions(+), 13 deletions(-)

diff --git a/vtkm/exec/internal/testing/UnitTestVariant.cxx b/vtkm/exec/internal/testing/UnitTestVariant.cxx
index bc37bec6d..fd3040968 100644
--- a/vtkm/exec/internal/testing/UnitTestVariant.cxx
+++ b/vtkm/exec/internal/testing/UnitTestVariant.cxx
@@ -34,7 +34,7 @@ static vtkm::Id g_NonTrivialCount;
 // A class that must is not trivial to copy nor construct.
 struct NonTrivial
 {
-  vtkm::Id Value = 12345;
+  vtkm::Id Value;
   NonTrivial* Self;
 
   void CheckState() const
@@ -44,17 +44,19 @@ struct NonTrivial
   }
 
   NonTrivial()
-    : Self(this)
+    : Value(12345)
+    , Self(this)
   {
     this->CheckState();
     ++g_NonTrivialCount;
   }
 
   NonTrivial(const NonTrivial& src)
-    : Self(this)
+    : Value(src.Value)
   {
-    this->CheckState();
     src.CheckState();
+    this->Self = this;
+    this->CheckState();
     ++g_NonTrivialCount;
   }
 
@@ -445,9 +447,9 @@ void TestCopyDestroy()
   using VariantType = vtkm::exec::internal::Variant<TypePlaceholder<0>,
                                                     TypePlaceholder<1>,
                                                     CountConstructDestruct,
-                                                    TypePlaceholder<2>,
-                                                    TypePlaceholder<3>>;
-#ifndef VTKM_USING_GLIBCXX_4
+                                                    TypePlaceholder<3>,
+                                                    TypePlaceholder<4>>;
+#ifdef VTKM_USE_STD_IS_TRIVIAL
   VTKM_STATIC_ASSERT(!std::is_trivially_copyable<VariantType>::value);
 #endif // !VTKM_USING_GLIBCXX_4
   vtkm::Id count = 0;
@@ -547,6 +549,19 @@ void TestConstructDestruct()
   VTKM_TEST_ASSERT(g_NonTrivialCount == 0);
 }
 
+void TestCopySelf()
+{
+  std::cout << "Make sure copying a Variant to itself works" << std::endl;
+
+  using VariantType =
+    vtkm::exec::internal::Variant<TypePlaceholder<0>, NonTrivial, TypePlaceholder<2>>;
+
+  VariantType variant{ NonTrivial{} };
+  VariantType& variantRef = variant;
+  variant = variantRef;
+  variant = variant.Get<NonTrivial>();
+}
+
 void RunTest()
 {
   TestSize();
@@ -557,6 +572,7 @@ void RunTest()
   TestCopyDestroy();
   TestEmplace();
   TestConstructDestruct();
+  TestCopySelf();
 }
 
 } // namespace test_variant
diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index 11acef38e..e4d17a8f6 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -56,13 +56,47 @@ template <typename UnionType>
 using VariantUnionToList =
   typename VariantUnionToListImpl<typename std::decay<UnionType>::type>::type;
 
+struct VariantCopyConstructFunctor
+{
+  template <typename T, typename UnionType>
+  VTK_M_DEVICE void operator()(const T& src, UnionType& destUnion) const noexcept
+  {
+    constexpr vtkm::IdComponent Index = vtkm::ListIndexOf<VariantUnionToList<UnionType>, T>::value;
+    // If we are using this functor, we can assume the union does not hold a valid type.
+    new (&VariantUnionGet<Index>(destUnion)) T(src);
+  }
+};
+
 struct VariantCopyFunctor
 {
   template <typename T, typename UnionType>
   VTK_M_DEVICE void operator()(const T& src, UnionType& destUnion) const noexcept
   {
     constexpr vtkm::IdComponent Index = vtkm::ListIndexOf<VariantUnionToList<UnionType>, T>::value;
-    new (&VariantUnionGet<Index>(destUnion)) T(src);
+    // If we are using this functor, we can assume the union holds type T.
+    this->DoCopy(
+      src, VariantUnionGet<Index>(destUnion), typename std::is_copy_assignable<T>::type{});
+  }
+
+  template <typename T>
+  VTK_M_DEVICE void DoCopy(const T& src, T& dest, std::true_type) const noexcept
+  {
+    dest = src;
+  }
+
+  template <typename T>
+  VTK_M_DEVICE void DoCopy(const T& src, T& dest, std::false_type) const noexcept
+  {
+    if (&src != &dest)
+    {
+      // Do not have an assignment operator, so destroy the old object and create a new one.
+      dest.~T();
+      new (&dest) T(src);
+    }
+    else
+    {
+      // Objects are already the same.
+    }
   }
 };
 
@@ -228,15 +262,22 @@ struct VariantConstructorImpl<vtkm::VTK_M_NAMESPACE::internal::Variant<Ts...>,
   VTK_M_DEVICE VariantConstructorImpl(const VariantConstructorImpl& src) noexcept
     : VariantStorageImpl<Ts...>(vtkm::internal::NullType{})
   {
-    src.CastAndCall(VariantCopyFunctor{}, this->Storage);
+    src.CastAndCall(VariantCopyConstructFunctor{}, this->Storage);
     this->Index = src.Index;
   }
 
   VTK_M_DEVICE VariantConstructorImpl& operator=(const VariantConstructorImpl& src) noexcept
   {
-    this->Reset();
-    src.CastAndCall(detail::VariantCopyFunctor{}, this->Storage);
-    this->Index = src.Index;
+    if (this->GetIndex() == src.GetIndex())
+    {
+      src.CastAndCall(detail::VariantCopyFunctor{}, this->Storage);
+    }
+    else
+    {
+      this->Reset();
+      src.CastAndCall(detail::VariantCopyConstructFunctor{}, this->Storage);
+      this->Index = src.Index;
+    }
     return *this;
   }
 };
@@ -312,7 +353,14 @@ public:
   template <typename T>
   VTK_M_DEVICE Variant& operator=(const T& src)
   {
-    this->Emplace<T>(src);
+    if (this->GetIndex() == this->GetIndexOf<T>())
+    {
+      this->Get<T>() = src;
+    }
+    else
+    {
+      this->Emplace<T>(src);
+    }
     return *this;
   }
 

From 9816c422b16a2a1e8e003ffe34e924508c53f65b Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 30 Mar 2021 09:01:08 -0600
Subject: [PATCH 06/11] Add padding to Grid struct in CellLocatorTwoLevel

There appears to be a bug in CUDA 9.2 where if you have a class that
contains a struct that itself has to have padding in the middle for
alignment purposes and you then put that class in a union with other
classes, it seems like that padding can cause problems with other
objects in the union.
---
 vtkm/exec/CellLocatorTwoLevel.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/vtkm/exec/CellLocatorTwoLevel.h b/vtkm/exec/CellLocatorTwoLevel.h
index c774891a0..c30e4c6e4 100644
--- a/vtkm/exec/CellLocatorTwoLevel.h
+++ b/vtkm/exec/CellLocatorTwoLevel.h
@@ -36,6 +36,10 @@ using FloatVec3 = vtkm::Vec3f;
 struct Grid
 {
   DimVec3 Dimensions;
+  // Bug in CUDA 9.2 where having this gap for alignment was for some reason setting garbage
+  // in a union with other cell locators (or perhaps not properly copying data). This appears
+  // to be fixed by CUDA 10.2.
+  DimensionType Padding;
   FloatVec3 Origin;
   FloatVec3 BinSize;
 };
@@ -54,6 +58,7 @@ VTKM_EXEC inline vtkm::Id ComputeFlatIndex(const DimVec3& idx, const DimVec3 dim
 VTKM_EXEC inline Grid ComputeLeafGrid(const DimVec3& idx, const DimVec3& dim, const Grid& l1Grid)
 {
   return { dim,
+           0,
            l1Grid.Origin + (static_cast<FloatVec3>(idx) * l1Grid.BinSize),
            l1Grid.BinSize / static_cast<FloatVec3>(dim) };
 }

From 7607736ef4b81f309fbb0ce20aa140ce45d03fec Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 30 Mar 2021 14:05:53 -0600
Subject: [PATCH 07/11] Reduce the number of lines required to implement
 AllTrivially*

---
 vtkm/internal/VariantImplDetail.h    | 913 +++------------------------
 vtkm/internal/VariantImplDetail.h.in |  91 +--
 2 files changed, 142 insertions(+), 862 deletions(-)

diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index 993d8469c..e71871bd7 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -51,258 +51,32 @@ struct VariantDummyReturn<void>
 
 // --------------------------------------------------------------------------------
 // Helper classes to determine if all Variant types are trivial.
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+          typename T1 = vtkm::internal::NullType,
+          typename T2 = vtkm::internal::NullType,
+          typename T3 = vtkm::internal::NullType,
+          typename T4 = vtkm::internal::NullType,
+          typename T5 = vtkm::internal::NullType,
+          typename T6 = vtkm::internal::NullType,
+          typename T7 = vtkm::internal::NullType,
+          typename T8 = vtkm::internal::NullType,
+          typename T9 = vtkm::internal::NullType,
+          typename T10 = vtkm::internal::NullType,
+          typename T11 = vtkm::internal::NullType,
+          typename T12 = vtkm::internal::NullType,
+          typename T13 = vtkm::internal::NullType,
+          typename T14 = vtkm::internal::NullType,
+          typename T15 = vtkm::internal::NullType,
+          typename T16 = vtkm::internal::NullType,
+          typename T17 = vtkm::internal::NullType,
+          typename T18 = vtkm::internal::NullType,
+          typename T19 = vtkm::internal::NullType,
+          typename... Ts>
 struct AllTriviallyCopyable;
 
-template <typename T0>
-struct AllTriviallyCopyable<T0>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  true)> { };
-template <typename T0, typename T1>
-struct AllTriviallyCopyable<T0, T1>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2>
-struct AllTriviallyCopyable<T0, T1, T2>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3>
-struct AllTriviallyCopyable<T0, T1, T2, T3>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  vtkmstd::is_trivially_copyable<T15>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  vtkmstd::is_trivially_copyable<T15>::value &&
-                                  vtkmstd::is_trivially_copyable<T16>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  vtkmstd::is_trivially_copyable<T15>::value &&
-                                  vtkmstd::is_trivially_copyable<T16>::value &&
-                                  vtkmstd::is_trivially_copyable<T17>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  vtkmstd::is_trivially_copyable<T15>::value &&
-                                  vtkmstd::is_trivially_copyable<T16>::value &&
-                                  vtkmstd::is_trivially_copyable<T17>::value &&
-                                  vtkmstd::is_trivially_copyable<T18>::value &&
-                                  true)> { };
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyCopyable<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
                                   vtkmstd::is_trivially_copyable<T1>::value &&
                                   vtkmstd::is_trivially_copyable<T2>::value &&
@@ -322,284 +96,41 @@ struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T1
                                   vtkmstd::is_trivially_copyable<T16>::value &&
                                   vtkmstd::is_trivially_copyable<T17>::value &&
                                   vtkmstd::is_trivially_copyable<T18>::value &&
-                                  vtkmstd::is_trivially_copyable<T19>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-                                  vtkmstd::is_trivially_copyable<T1>::value &&
-                                  vtkmstd::is_trivially_copyable<T2>::value &&
-                                  vtkmstd::is_trivially_copyable<T3>::value &&
-                                  vtkmstd::is_trivially_copyable<T4>::value &&
-                                  vtkmstd::is_trivially_copyable<T5>::value &&
-                                  vtkmstd::is_trivially_copyable<T6>::value &&
-                                  vtkmstd::is_trivially_copyable<T7>::value &&
-                                  vtkmstd::is_trivially_copyable<T8>::value &&
-                                  vtkmstd::is_trivially_copyable<T9>::value &&
-                                  vtkmstd::is_trivially_copyable<T10>::value &&
-                                  vtkmstd::is_trivially_copyable<T11>::value &&
-                                  vtkmstd::is_trivially_copyable<T12>::value &&
-                                  vtkmstd::is_trivially_copyable<T13>::value &&
-                                  vtkmstd::is_trivially_copyable<T14>::value &&
-                                  vtkmstd::is_trivially_copyable<T15>::value &&
-                                  vtkmstd::is_trivially_copyable<T16>::value &&
-                                  vtkmstd::is_trivially_copyable<T17>::value &&
-                                  vtkmstd::is_trivially_copyable<T18>::value &&
-                                  vtkmstd::is_trivially_copyable<T19>::value &&
-                                  AllTriviallyCopyable<T20, Ts...>::value)> { };
+                                  vtkmstd::is_trivially_copyable<T19>::value)> { };
 
-template <typename... Ts>
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+struct AllTriviallyCopyable<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
+      AllTriviallyCopyable<T20, Ts...>::value)> {  };
+
+template <typename T0 = vtkm::internal::NullType,
+          typename T1 = vtkm::internal::NullType,
+          typename T2 = vtkm::internal::NullType,
+          typename T3 = vtkm::internal::NullType,
+          typename T4 = vtkm::internal::NullType,
+          typename T5 = vtkm::internal::NullType,
+          typename T6 = vtkm::internal::NullType,
+          typename T7 = vtkm::internal::NullType,
+          typename T8 = vtkm::internal::NullType,
+          typename T9 = vtkm::internal::NullType,
+          typename T10 = vtkm::internal::NullType,
+          typename T11 = vtkm::internal::NullType,
+          typename T12 = vtkm::internal::NullType,
+          typename T13 = vtkm::internal::NullType,
+          typename T14 = vtkm::internal::NullType,
+          typename T15 = vtkm::internal::NullType,
+          typename T16 = vtkm::internal::NullType,
+          typename T17 = vtkm::internal::NullType,
+          typename T18 = vtkm::internal::NullType,
+          typename T19 = vtkm::internal::NullType,
+          typename... Ts>
 struct AllTriviallyConstructible;
 
-template <typename T0>
-struct AllTriviallyConstructible<T0>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  true)> { };
-template <typename T0, typename T1>
-struct AllTriviallyConstructible<T0, T1>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2>
-struct AllTriviallyConstructible<T0, T1, T2>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3>
-struct AllTriviallyConstructible<T0, T1, T2, T3>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  vtkmstd::is_trivially_constructible<T15>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  vtkmstd::is_trivially_constructible<T15>::value &&
-                                  vtkmstd::is_trivially_constructible<T16>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  vtkmstd::is_trivially_constructible<T15>::value &&
-                                  vtkmstd::is_trivially_constructible<T16>::value &&
-                                  vtkmstd::is_trivially_constructible<T17>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  vtkmstd::is_trivially_constructible<T15>::value &&
-                                  vtkmstd::is_trivially_constructible<T16>::value &&
-                                  vtkmstd::is_trivially_constructible<T17>::value &&
-                                  vtkmstd::is_trivially_constructible<T18>::value &&
-                                  true)> { };
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyConstructible<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
                                   vtkmstd::is_trivially_constructible<T1>::value &&
                                   vtkmstd::is_trivially_constructible<T2>::value &&
@@ -619,284 +150,41 @@ struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T1
                                   vtkmstd::is_trivially_constructible<T16>::value &&
                                   vtkmstd::is_trivially_constructible<T17>::value &&
                                   vtkmstd::is_trivially_constructible<T18>::value &&
-                                  vtkmstd::is_trivially_constructible<T19>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-                                  vtkmstd::is_trivially_constructible<T1>::value &&
-                                  vtkmstd::is_trivially_constructible<T2>::value &&
-                                  vtkmstd::is_trivially_constructible<T3>::value &&
-                                  vtkmstd::is_trivially_constructible<T4>::value &&
-                                  vtkmstd::is_trivially_constructible<T5>::value &&
-                                  vtkmstd::is_trivially_constructible<T6>::value &&
-                                  vtkmstd::is_trivially_constructible<T7>::value &&
-                                  vtkmstd::is_trivially_constructible<T8>::value &&
-                                  vtkmstd::is_trivially_constructible<T9>::value &&
-                                  vtkmstd::is_trivially_constructible<T10>::value &&
-                                  vtkmstd::is_trivially_constructible<T11>::value &&
-                                  vtkmstd::is_trivially_constructible<T12>::value &&
-                                  vtkmstd::is_trivially_constructible<T13>::value &&
-                                  vtkmstd::is_trivially_constructible<T14>::value &&
-                                  vtkmstd::is_trivially_constructible<T15>::value &&
-                                  vtkmstd::is_trivially_constructible<T16>::value &&
-                                  vtkmstd::is_trivially_constructible<T17>::value &&
-                                  vtkmstd::is_trivially_constructible<T18>::value &&
-                                  vtkmstd::is_trivially_constructible<T19>::value &&
-                                  AllTriviallyConstructible<T20, Ts...>::value)> { };
+                                  vtkmstd::is_trivially_constructible<T19>::value)> { };
 
-template <typename... Ts>
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
+struct AllTriviallyConstructible<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
+      AllTriviallyConstructible<T20, Ts...>::value)> {  };
+
+template <typename T0 = vtkm::internal::NullType,
+          typename T1 = vtkm::internal::NullType,
+          typename T2 = vtkm::internal::NullType,
+          typename T3 = vtkm::internal::NullType,
+          typename T4 = vtkm::internal::NullType,
+          typename T5 = vtkm::internal::NullType,
+          typename T6 = vtkm::internal::NullType,
+          typename T7 = vtkm::internal::NullType,
+          typename T8 = vtkm::internal::NullType,
+          typename T9 = vtkm::internal::NullType,
+          typename T10 = vtkm::internal::NullType,
+          typename T11 = vtkm::internal::NullType,
+          typename T12 = vtkm::internal::NullType,
+          typename T13 = vtkm::internal::NullType,
+          typename T14 = vtkm::internal::NullType,
+          typename T15 = vtkm::internal::NullType,
+          typename T16 = vtkm::internal::NullType,
+          typename T17 = vtkm::internal::NullType,
+          typename T18 = vtkm::internal::NullType,
+          typename T19 = vtkm::internal::NullType,
+          typename... Ts>
 struct AllTriviallyDestructible;
 
-template <typename T0>
-struct AllTriviallyDestructible<T0>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  true)> { };
-template <typename T0, typename T1>
-struct AllTriviallyDestructible<T0, T1>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2>
-struct AllTriviallyDestructible<T0, T1, T2>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3>
-struct AllTriviallyDestructible<T0, T1, T2, T3>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  vtkmstd::is_trivially_destructible<T15>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  vtkmstd::is_trivially_destructible<T15>::value &&
-                                  vtkmstd::is_trivially_destructible<T16>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  vtkmstd::is_trivially_destructible<T15>::value &&
-                                  vtkmstd::is_trivially_destructible<T16>::value &&
-                                  vtkmstd::is_trivially_destructible<T17>::value &&
-                                  true)> { };
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  vtkmstd::is_trivially_destructible<T15>::value &&
-                                  vtkmstd::is_trivially_destructible<T16>::value &&
-                                  vtkmstd::is_trivially_destructible<T17>::value &&
-                                  vtkmstd::is_trivially_destructible<T18>::value &&
-                                  true)> { };
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyDestructible<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
                                   vtkmstd::is_trivially_destructible<T1>::value &&
                                   vtkmstd::is_trivially_destructible<T2>::value &&
@@ -916,31 +204,14 @@ struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11
                                   vtkmstd::is_trivially_destructible<T16>::value &&
                                   vtkmstd::is_trivially_destructible<T17>::value &&
                                   vtkmstd::is_trivially_destructible<T18>::value &&
-                                  vtkmstd::is_trivially_destructible<T19>::value &&
-                                  true)> { };
+                                  vtkmstd::is_trivially_destructible<T19>::value)> { };
+
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-                                  vtkmstd::is_trivially_destructible<T1>::value &&
-                                  vtkmstd::is_trivially_destructible<T2>::value &&
-                                  vtkmstd::is_trivially_destructible<T3>::value &&
-                                  vtkmstd::is_trivially_destructible<T4>::value &&
-                                  vtkmstd::is_trivially_destructible<T5>::value &&
-                                  vtkmstd::is_trivially_destructible<T6>::value &&
-                                  vtkmstd::is_trivially_destructible<T7>::value &&
-                                  vtkmstd::is_trivially_destructible<T8>::value &&
-                                  vtkmstd::is_trivially_destructible<T9>::value &&
-                                  vtkmstd::is_trivially_destructible<T10>::value &&
-                                  vtkmstd::is_trivially_destructible<T11>::value &&
-                                  vtkmstd::is_trivially_destructible<T12>::value &&
-                                  vtkmstd::is_trivially_destructible<T13>::value &&
-                                  vtkmstd::is_trivially_destructible<T14>::value &&
-                                  vtkmstd::is_trivially_destructible<T15>::value &&
-                                  vtkmstd::is_trivially_destructible<T16>::value &&
-                                  vtkmstd::is_trivially_destructible<T17>::value &&
-                                  vtkmstd::is_trivially_destructible<T18>::value &&
-                                  vtkmstd::is_trivially_destructible<T19>::value &&
-                                  AllTriviallyDestructible<T20, Ts...>::value)> { };
+struct AllTriviallyDestructible<
+    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
+      AllTriviallyDestructible<T20, Ts...>::value)> {  };
 
 // --------------------------------------------------------------------------------
 // Union type used inside of Variant
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index 34e43465c..b69c29f1b 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -84,65 +84,74 @@ struct VariantDummyReturn<void>
 
 // --------------------------------------------------------------------------------
 // Helper classes to determine if all Variant types are trivial.
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+$for(param_index in range(1, max_expanded))\
+          typename T$(param_index) = vtkm::internal::NullType,
+$endfor\
+          typename... Ts>
 struct AllTriviallyCopyable;
 
-$for(num_params in range(max_expanded))\
-template <$typename_list(num_params)>
-struct AllTriviallyCopyable<$type_list(num_params)>
+template <$typename_list(max_expanded - 1)>
+struct AllTriviallyCopyable<
+    $type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-$for(param_index in range(1, num_params + 1))\
+$for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_copyable<T$(param_index)>::value &&
 $endfor\
-                                  true)> { };
-$endfor\
-template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyCopyable<$type_list(max_expanded), Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
-$for(param_index in range(1, max_expanded))\
-                                  vtkmstd::is_trivially_copyable<T$(param_index)>::value &&
-$endfor\
-                                  AllTriviallyCopyable<T$(max_expanded), Ts...>::value)> { };
+                                  vtkmstd::is_trivially_copyable<T$(max_expanded - 1)>::value)> { };
 
-template <typename... Ts>
+template <$typename_list(max_expanded), typename... Ts>
+struct AllTriviallyCopyable<
+    $type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyCopyable<$type_list(max_expanded - 1)>::value &&
+      AllTriviallyCopyable<T$(max_expanded), Ts...>::value)> {  };
+
+template <typename T0 = vtkm::internal::NullType,
+$for(param_index in range(1, max_expanded))\
+          typename T$(param_index) = vtkm::internal::NullType,
+$endfor\
+          typename... Ts>
 struct AllTriviallyConstructible;
 
-$for(num_params in range(max_expanded))\
-template <$typename_list(num_params)>
-struct AllTriviallyConstructible<$type_list(num_params)>
+template <$typename_list(max_expanded - 1)>
+struct AllTriviallyConstructible<
+    $type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-$for(param_index in range(1, num_params + 1))\
+$for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_constructible<T$(param_index)>::value &&
 $endfor\
-                                  true)> { };
-$endfor\
-template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyConstructible<$type_list(max_expanded), Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
-$for(param_index in range(1, max_expanded))\
-                                  vtkmstd::is_trivially_constructible<T$(param_index)>::value &&
-$endfor\
-                                  AllTriviallyConstructible<T$(max_expanded), Ts...>::value)> { };
+                                  vtkmstd::is_trivially_constructible<T$(max_expanded - 1)>::value)> { };
 
-template <typename... Ts>
+template <$typename_list(max_expanded), typename... Ts>
+struct AllTriviallyConstructible<
+    $type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyConstructible<$type_list(max_expanded - 1)>::value &&
+      AllTriviallyConstructible<T$(max_expanded), Ts...>::value)> {  };
+
+template <typename T0 = vtkm::internal::NullType,
+$for(param_index in range(1, max_expanded))\
+          typename T$(param_index) = vtkm::internal::NullType,
+$endfor\
+          typename... Ts>
 struct AllTriviallyDestructible;
 
-$for(num_params in range(max_expanded))\
-template <$typename_list(num_params)>
-struct AllTriviallyDestructible<$type_list(num_params)>
+template <$typename_list(max_expanded - 1)>
+struct AllTriviallyDestructible<
+    $type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-$for(param_index in range(1, num_params + 1))\
+$for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_destructible<T$(param_index)>::value &&
 $endfor\
-                                  true)> { };
-$endfor\
+                                  vtkmstd::is_trivially_destructible<T$(max_expanded - 1)>::value)> { };
+
 template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyDestructible<$type_list(max_expanded), Ts...>
-  : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
-$for(param_index in range(1, max_expanded))\
-                                  vtkmstd::is_trivially_destructible<T$(param_index)>::value &&
-$endfor\
-                                  AllTriviallyDestructible<T$(max_expanded), Ts...>::value)> { };
+struct AllTriviallyDestructible<
+    $type_list(max_expanded), Ts...>
+  : std::integral_constant<bool, (
+      AllTriviallyDestructible<$type_list(max_expanded - 1)>::value &&
+      AllTriviallyDestructible<T$(max_expanded), Ts...>::value)> {  };
 
 // --------------------------------------------------------------------------------
 // Union type used inside of Variant

From 991eeba9f33a807145d32d5c857ca88ed612b031 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 30 Mar 2021 14:35:44 -0600
Subject: [PATCH 08/11] Reduce the number of lines required to implement
 VariantUnion

---
 vtkm/internal/VariantImplDetail.h    | 732 ++-------------------------
 vtkm/internal/VariantImplDetail.h.in |  49 +-
 2 files changed, 78 insertions(+), 703 deletions(-)

diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index e71871bd7..0c00a9a58 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -75,8 +75,7 @@ template <typename T0 = vtkm::internal::NullType,
 struct AllTriviallyCopyable;
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyCopyable<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
                                   vtkmstd::is_trivially_copyable<T1>::value &&
                                   vtkmstd::is_trivially_copyable<T2>::value &&
@@ -99,8 +98,7 @@ struct AllTriviallyCopyable<
                                   vtkmstd::is_trivially_copyable<T19>::value)> { };
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyCopyable<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+struct AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
   : std::integral_constant<bool, (
       AllTriviallyCopyable<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
       AllTriviallyCopyable<T20, Ts...>::value)> {  };
@@ -129,8 +127,7 @@ template <typename T0 = vtkm::internal::NullType,
 struct AllTriviallyConstructible;
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyConstructible<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
                                   vtkmstd::is_trivially_constructible<T1>::value &&
                                   vtkmstd::is_trivially_constructible<T2>::value &&
@@ -153,8 +150,7 @@ struct AllTriviallyConstructible<
                                   vtkmstd::is_trivially_constructible<T19>::value)> { };
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyConstructible<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+struct AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
   : std::integral_constant<bool, (
       AllTriviallyConstructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
       AllTriviallyConstructible<T20, Ts...>::value)> {  };
@@ -183,8 +179,7 @@ template <typename T0 = vtkm::internal::NullType,
 struct AllTriviallyDestructible;
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
-struct AllTriviallyDestructible<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
   : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
                                   vtkmstd::is_trivially_destructible<T1>::value &&
                                   vtkmstd::is_trivially_destructible<T2>::value &&
@@ -207,8 +202,7 @@ struct AllTriviallyDestructible<
                                   vtkmstd::is_trivially_destructible<T19>::value)> { };
 
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
-struct AllTriviallyDestructible<
-    T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
+struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
   : std::integral_constant<bool, (
       AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>::value &&
       AllTriviallyDestructible<T20, Ts...>::value)> {  };
@@ -242,678 +236,53 @@ struct AllTriviallyDestructible<
 //
 
 // TD = trivially deconstructible
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+          typename T1 = vtkm::internal::NullType,
+          typename T2 = vtkm::internal::NullType,
+          typename T3 = vtkm::internal::NullType,
+          typename T4 = vtkm::internal::NullType,
+          typename T5 = vtkm::internal::NullType,
+          typename T6 = vtkm::internal::NullType,
+          typename T7 = vtkm::internal::NullType,
+          typename T8 = vtkm::internal::NullType,
+          typename T9 = vtkm::internal::NullType,
+          typename T10 = vtkm::internal::NullType,
+          typename T11 = vtkm::internal::NullType,
+          typename T12 = vtkm::internal::NullType,
+          typename T13 = vtkm::internal::NullType,
+          typename T14 = vtkm::internal::NullType,
+          typename T15 = vtkm::internal::NullType,
+          typename T16 = vtkm::internal::NullType,
+          typename T17 = vtkm::internal::NullType,
+          typename T18 = vtkm::internal::NullType,
+          typename T19 = vtkm::internal::NullType,
+          typename... Ts>
 union VariantUnionTD;
 
 // NTD = non-trivially deconstructible
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+          typename T1 = vtkm::internal::NullType,
+          typename T2 = vtkm::internal::NullType,
+          typename T3 = vtkm::internal::NullType,
+          typename T4 = vtkm::internal::NullType,
+          typename T5 = vtkm::internal::NullType,
+          typename T6 = vtkm::internal::NullType,
+          typename T7 = vtkm::internal::NullType,
+          typename T8 = vtkm::internal::NullType,
+          typename T9 = vtkm::internal::NullType,
+          typename T10 = vtkm::internal::NullType,
+          typename T11 = vtkm::internal::NullType,
+          typename T12 = vtkm::internal::NullType,
+          typename T13 = vtkm::internal::NullType,
+          typename T14 = vtkm::internal::NullType,
+          typename T15 = vtkm::internal::NullType,
+          typename T16 = vtkm::internal::NullType,
+          typename T17 = vtkm::internal::NullType,
+          typename T18 = vtkm::internal::NullType,
+          typename T19 = vtkm::internal::NullType,
+          typename... Ts>
 union VariantUnionNTD;
 
-template <typename T0>
-union VariantUnionTD<T0>
-{
-  T0 V0;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0>
-union VariantUnionNTD<T0>
-{
-  T0 V0;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1>
-union VariantUnionTD<T0, T1>
-{
-  T0 V0;
-  T1 V1;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1>
-union VariantUnionNTD<T0, T1>
-{
-  T0 V0;
-  T1 V1;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2>
-union VariantUnionTD<T0, T1, T2>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2>
-union VariantUnionNTD<T0, T1, T2>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3>
-union VariantUnionTD<T0, T1, T2, T3>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3>
-union VariantUnionNTD<T0, T1, T2, T3>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4>
-union VariantUnionTD<T0, T1, T2, T3, T4>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4>
-union VariantUnionNTD<T0, T1, T2, T3, T4>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  T17 V17;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  T17 V17;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
-union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  T17 V17;
-  T18 V18;
-  VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
-  VariantUnionTD() = default;
-};
-
-template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
-union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>
-{
-  T0 V0;
-  T1 V1;
-  T2 V2;
-  T3 V3;
-  T4 V4;
-  T5 V5;
-  T6 V6;
-  T7 V7;
-  T8 V8;
-  T9 V9;
-  T10 V10;
-  T11 V11;
-  T12 V12;
-  T13 V13;
-  T14 V14;
-  T15 V15;
-  T16 V16;
-  T17 V17;
-  T18 V18;
-  VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
-  VariantUnionNTD() = default;
-  VTK_M_DEVICE ~VariantUnionNTD() { }
-};
-
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
 union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>
 {
@@ -937,6 +306,7 @@ union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
   T17 V17;
   T18 V18;
   T19 V19;
+
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
 };
@@ -964,12 +334,12 @@ union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
   T17 V17;
   T18 V18;
   T19 V19;
+
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
   VTK_M_DEVICE ~VariantUnionNTD() { }
 };
 
-
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
 union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
 {
@@ -995,6 +365,7 @@ union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
   T18 V18;
   T19 V19;
   VariantUnionTD<T20, Ts...> Remaining;
+
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
 };
@@ -1024,6 +395,7 @@ union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
   T18 V18;
   T19 V19;
   VariantUnionNTD<T20, Ts...> Remaining;
+
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
   VTK_M_DEVICE ~VariantUnionNTD() { }
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index b69c29f1b..4942d931a 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -92,8 +92,7 @@ $endfor\
 struct AllTriviallyCopyable;
 
 template <$typename_list(max_expanded - 1)>
-struct AllTriviallyCopyable<
-    $type_list(max_expanded - 1)>
+struct AllTriviallyCopyable<$type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_copyable<T0>::value &&
 $for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_copyable<T$(param_index)>::value &&
@@ -101,8 +100,7 @@ $endfor\
                                   vtkmstd::is_trivially_copyable<T$(max_expanded - 1)>::value)> { };
 
 template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyCopyable<
-    $type_list(max_expanded), Ts...>
+struct AllTriviallyCopyable<$type_list(max_expanded), Ts...>
   : std::integral_constant<bool, (
       AllTriviallyCopyable<$type_list(max_expanded - 1)>::value &&
       AllTriviallyCopyable<T$(max_expanded), Ts...>::value)> {  };
@@ -115,8 +113,7 @@ $endfor\
 struct AllTriviallyConstructible;
 
 template <$typename_list(max_expanded - 1)>
-struct AllTriviallyConstructible<
-    $type_list(max_expanded - 1)>
+struct AllTriviallyConstructible<$type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_constructible<T0>::value &&
 $for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_constructible<T$(param_index)>::value &&
@@ -124,8 +121,7 @@ $endfor\
                                   vtkmstd::is_trivially_constructible<T$(max_expanded - 1)>::value)> { };
 
 template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyConstructible<
-    $type_list(max_expanded), Ts...>
+struct AllTriviallyConstructible<$type_list(max_expanded), Ts...>
   : std::integral_constant<bool, (
       AllTriviallyConstructible<$type_list(max_expanded - 1)>::value &&
       AllTriviallyConstructible<T$(max_expanded), Ts...>::value)> {  };
@@ -138,8 +134,7 @@ $endfor\
 struct AllTriviallyDestructible;
 
 template <$typename_list(max_expanded - 1)>
-struct AllTriviallyDestructible<
-    $type_list(max_expanded - 1)>
+struct AllTriviallyDestructible<$type_list(max_expanded - 1)>
   : std::integral_constant<bool, (vtkmstd::is_trivially_destructible<T0>::value &&
 $for(param_index in range(1, max_expanded - 1))\
                                   vtkmstd::is_trivially_destructible<T$(param_index)>::value &&
@@ -147,8 +142,7 @@ $endfor\
                                   vtkmstd::is_trivially_destructible<T$(max_expanded - 1)>::value)> { };
 
 template <$typename_list(max_expanded), typename... Ts>
-struct AllTriviallyDestructible<
-    $type_list(max_expanded), Ts...>
+struct AllTriviallyDestructible<$type_list(max_expanded), Ts...>
   : std::integral_constant<bool, (
       AllTriviallyDestructible<$type_list(max_expanded - 1)>::value &&
       AllTriviallyDestructible<T$(max_expanded), Ts...>::value)> {  };
@@ -182,37 +176,44 @@ struct AllTriviallyDestructible<
 //
 
 // TD = trivially deconstructible
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+$for(param_index in range(1, max_expanded))\
+          typename T$(param_index) = vtkm::internal::NullType,
+$endfor\
+          typename... Ts>
 union VariantUnionTD;
 
 // NTD = non-trivially deconstructible
-template <typename... Ts>
+template <typename T0 = vtkm::internal::NullType,
+$for(param_index in range(1, max_expanded))\
+          typename T$(param_index) = vtkm::internal::NullType,
+$endfor\
+          typename... Ts>
 union VariantUnionNTD;
 
-$for(num_params in range(max_expanded))\
-template <$typename_list(num_params)>
-union VariantUnionTD<$type_list(num_params)>
+template <$typename_list(max_expanded - 1)>
+union VariantUnionTD<$type_list(max_expanded - 1)>
 {
-$for(param_index in range(num_params + 1))\
+$for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
+
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
 };
 
-template <$typename_list(num_params)>
-union VariantUnionNTD<$type_list(num_params)>
+template <$typename_list(max_expanded - 1)>
+union VariantUnionNTD<$type_list(max_expanded - 1)>
 {
-$for(param_index in range(num_params + 1))\
+$for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
+
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
   VTK_M_DEVICE ~VariantUnionNTD() { }
 };
 
-$endfor\
-
 template <$typename_list(max_expanded), typename... Ts>
 union VariantUnionTD<$type_list(max_expanded), Ts...>
 {
@@ -221,6 +222,7 @@ $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
   VariantUnionTD<T$(max_expanded), Ts...> Remaining;
+
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
 };
@@ -233,6 +235,7 @@ $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
   VariantUnionNTD<T$(max_expanded), Ts...> Remaining;
+
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
   VTK_M_DEVICE ~VariantUnionNTD() { }

From 647bc94fed9abbff2833ef64dda9c511d2db2c0f Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Tue, 30 Mar 2021 15:22:38 -0600
Subject: [PATCH 09/11] Reduce the number of lines required to implement
 Variant::CastAndCall

---
 vtkm/internal/VariantImpl.h          |   26 +-
 vtkm/internal/VariantImplDetail.h    | 1063 +++++---------------------
 vtkm/internal/VariantImplDetail.h.in |  111 ++-
 3 files changed, 261 insertions(+), 939 deletions(-)

diff --git a/vtkm/internal/VariantImpl.h b/vtkm/internal/VariantImpl.h
index e4d17a8f6..90afb3807 100644
--- a/vtkm/internal/VariantImpl.h
+++ b/vtkm/internal/VariantImpl.h
@@ -179,11 +179,8 @@ struct VariantStorageImpl
       -> decltype(f(std::declval<const TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
-    return detail::VariantCastAndCallImpl(vtkm::ListSize<vtkm::List<Ts...>>{},
-                                          this->GetIndex(),
-                                          std::forward<Functor>(f),
-                                          this->Storage,
-                                          std::forward<Args>(args)...);
+    return detail::VariantCastAndCallImpl(
+      this->GetIndex(), std::forward<Functor>(f), this->Storage, std::forward<Args>(args)...);
   }
 
   template <typename Functor, typename... Args>
@@ -192,11 +189,8 @@ struct VariantStorageImpl
     -> decltype(f(std::declval<TypeAt<0>&>(), args...))
   {
     VTKM_ASSERT(this->IsValid());
-    return detail::VariantCastAndCallImpl(vtkm::ListSize<vtkm::List<Ts...>>{},
-                                          this->GetIndex(),
-                                          std::forward<Functor>(f),
-                                          this->Storage,
-                                          std::forward<Args>(args)...);
+    return detail::VariantCastAndCallImpl(
+      this->GetIndex(), std::forward<Functor>(f), this->Storage, std::forward<Args>(args)...);
   }
 };
 
@@ -466,11 +460,7 @@ public:
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl(
-      std::integral_constant<vtkm::IdComponent, NumberOfTypes>{},
-      this->GetIndex(),
-      std::forward<Functor>(f),
-      this->Storage,
-      std::forward<Args>(args)...);
+      this->GetIndex(), std::forward<Functor>(f), this->Storage, std::forward<Args>(args)...);
   }
 
   template <typename Functor, typename... Args>
@@ -480,11 +470,7 @@ public:
   {
     VTKM_ASSERT(this->IsValid());
     return detail::VariantCastAndCallImpl(
-      std::integral_constant<vtkm::IdComponent, NumberOfTypes>{},
-      this->GetIndex(),
-      std::forward<Functor>(f),
-      this->Storage,
-      std::forward<Args>(args)...);
+      this->GetIndex(), std::forward<Functor>(f), this->Storage, std::forward<Args>(args)...);
   }
 
   /// Destroys any object the Variant is holding and sets the Variant to an invalid state. This
diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index 0c00a9a58..6e9bc3c2b 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -306,6 +306,7 @@ union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
   T17 V17;
   T18 V18;
   T19 V19;
+  vtkm::internal::NullType Remaining;
 
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
@@ -334,6 +335,7 @@ union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
   T17 V17;
   T18 V18;
   T19 V19;
+  vtkm::internal::NullType Remaining;
 
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
@@ -343,7 +345,6 @@ union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
 union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
 {
-  vtkm::internal::NullType Dummy;
   T0 V0;
   T1 V1;
   T2 V2;
@@ -373,7 +374,6 @@ union VariantUnionTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
 template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename... Ts>
 union VariantUnionNTD<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, Ts...>
 {
-  vtkm::internal::NullType Dummy;
   T0 V0;
   T1 V1;
   T2 V2;
@@ -728,892 +728,201 @@ VTK_M_DEVICE auto VariantUnionGet(UnionType& storage) noexcept
   return VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage);
 }
 
-// --------------------------------------------------------------------------------
-// Internal implementation of CastAndCall for Variant
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 1>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 2>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 3>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 4>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 5>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 6>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 7>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 8>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 9>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 10>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 11>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 12>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 13>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 14>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 15>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 16>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 17>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    case 16:
-      return f(storage.V16, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 18>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    case 16:
-      return f(storage.V16, std::forward<Args>(args)...);
-    case 17:
-      return f(storage.V17, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 19>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    case 16:
-      return f(storage.V16, std::forward<Args>(args)...);
-    case 17:
-      return f(storage.V17, std::forward<Args>(args)...);
-    case 18:
-      return f(storage.V18, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, 20>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    case 16:
-      return f(storage.V16, std::forward<Args>(args)...);
-    case 17:
-      return f(storage.V17, std::forward<Args>(args)...);
-    case 18:
-      return f(storage.V18, std::forward<Args>(args)...);
-    case 19:
-      return f(storage.V19, std::forward<Args>(args)...);
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
 //clang-format on
 
-// Recurse for cases where Variant has more than 20 types
-template <vtkm::IdComponent N,
+// --------------------------------------------------------------------------------
+// Internal implementation of CastAndCall for Variant
+template <typename ReturnType,
           typename Functor,
-          typename UnionType,
+          typename CastMember,
           typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCallFunctor(
+  std::false_type,
+  Functor&& f,
+  CastMember& value,
+  Args&&... args) noexcept(noexcept(f(value, args...)))
+{
+  // If you get a compile error here, it probably means that you have called Variant::CastAndCall
+  // with a functor that does not accept one of the types in the Variant. The functor you provide
+  // must be callable with all types in the Variant, not just the one that it currently holds.
+  return f(value, std::forward<Args>(args)...);
+}
+
+template <typename ReturnType,
+          typename Functor,
+          typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCallFunctor(
+  std::true_type, Functor&&, vtkm::internal::NullType, Args&&...) noexcept
+{
+  // If we are here, it means a Variant had an inappropriate index.
+  VTKM_ASSERT(false && "Internal error, bad Variant state.");
+  return VariantDummyReturn<ReturnType>::F();
+}
+
+// Terminating condition in recursive template
+template <typename ReturnType, typename Functor, typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCastAndCallImplR(
+  std::true_type,
+  vtkm::IdComponent vtkmNotUsed(index),
+  Functor&& vtkmNotUsed(f),
+  vtkm::internal::NullType,
+  Args&&... vtkmNotUsed(args)) noexcept
+{
+  // If we are here, it means a Variant had an inappropriate index.
+  VTKM_ASSERT(false && "Internal error, bad Variant state.");
+  return VariantDummyReturn<ReturnType>::F();
+}
+
+template <typename ReturnType, typename Functor, typename UnionType, typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCastAndCallImplR(
+  std::false_type,
+  vtkm::IdComponent index,
+  Functor&& f,
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+{
+  switch (index)
+  {
+    case 0:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V0), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V0,
+        std::forward<Args>(args)...);
+    case 1:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V1), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V1,
+        std::forward<Args>(args)...);
+    case 2:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V2), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V2,
+        std::forward<Args>(args)...);
+    case 3:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V3), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V3,
+        std::forward<Args>(args)...);
+    case 4:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V4), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V4,
+        std::forward<Args>(args)...);
+    case 5:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V5), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V5,
+        std::forward<Args>(args)...);
+    case 6:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V6), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V6,
+        std::forward<Args>(args)...);
+    case 7:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V7), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V7,
+        std::forward<Args>(args)...);
+    case 8:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V8), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V8,
+        std::forward<Args>(args)...);
+    case 9:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V9), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V9,
+        std::forward<Args>(args)...);
+    case 10:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V10), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V10,
+        std::forward<Args>(args)...);
+    case 11:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V11), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V11,
+        std::forward<Args>(args)...);
+    case 12:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V12), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V12,
+        std::forward<Args>(args)...);
+    case 13:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V13), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V13,
+        std::forward<Args>(args)...);
+    case 14:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V14), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V14,
+        std::forward<Args>(args)...);
+    case 15:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V15), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V15,
+        std::forward<Args>(args)...);
+    case 16:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V16), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V16,
+        std::forward<Args>(args)...);
+    case 17:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V17), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V17,
+        std::forward<Args>(args)...);
+    case 18:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V18), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V18,
+        std::forward<Args>(args)...);
+    case 19:
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V19), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V19,
+        std::forward<Args>(args)...);
+    default:
+      return VariantCastAndCallImplR<ReturnType>(
+        typename std::is_same<decltype(storage.Remaining), vtkm::internal::NullType>::type{},
+        index - 20,
+        std::forward<Functor>(f),
+        storage.Remaining,
+        std::forward<Args>(args)...);
+  }
+}
+
+template <typename Functor, typename UnionType, typename... Args>
 VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, N>,
   vtkm::IdComponent index,
   Functor&& f,
   UnionType& storage,
   Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
   -> decltype(f(storage.V0, args...))
 {
-  switch (index)
-  {
-    case 0:
-      return f(storage.V0, std::forward<Args>(args)...);
-    case 1:
-      return f(storage.V1, std::forward<Args>(args)...);
-    case 2:
-      return f(storage.V2, std::forward<Args>(args)...);
-    case 3:
-      return f(storage.V3, std::forward<Args>(args)...);
-    case 4:
-      return f(storage.V4, std::forward<Args>(args)...);
-    case 5:
-      return f(storage.V5, std::forward<Args>(args)...);
-    case 6:
-      return f(storage.V6, std::forward<Args>(args)...);
-    case 7:
-      return f(storage.V7, std::forward<Args>(args)...);
-    case 8:
-      return f(storage.V8, std::forward<Args>(args)...);
-    case 9:
-      return f(storage.V9, std::forward<Args>(args)...);
-    case 10:
-      return f(storage.V10, std::forward<Args>(args)...);
-    case 11:
-      return f(storage.V11, std::forward<Args>(args)...);
-    case 12:
-      return f(storage.V12, std::forward<Args>(args)...);
-    case 13:
-      return f(storage.V13, std::forward<Args>(args)...);
-    case 14:
-      return f(storage.V14, std::forward<Args>(args)...);
-    case 15:
-      return f(storage.V15, std::forward<Args>(args)...);
-    case 16:
-      return f(storage.V16, std::forward<Args>(args)...);
-    case 17:
-      return f(storage.V17, std::forward<Args>(args)...);
-    case 18:
-      return f(storage.V18, std::forward<Args>(args)...);
-    case 19:
-      return f(storage.V19, std::forward<Args>(args)...);
-    default:
-      return VariantCastAndCallImpl(std::integral_constant<vtkm::IdComponent, N - 20>{},
-                                    index - 20,
-                                    std::forward<Functor>(f),
-                                    storage.Remaining,
-                                    std::forward<Args>(args)...);
-  }
+  return VariantCastAndCallImplR<decltype(f(storage.V0, args...))>(
+    std::false_type{}, index, std::forward<Functor>(f), storage, std::forward<Args>(args)...);
 }
 
 }
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index 4942d931a..39587939e 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -197,6 +197,7 @@ union VariantUnionTD<$type_list(max_expanded - 1)>
 $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
+  vtkm::internal::NullType Remaining;
 
   VTK_M_DEVICE VariantUnionTD(vtkm::internal::NullType) { }
   VariantUnionTD() = default;
@@ -208,6 +209,7 @@ union VariantUnionNTD<$type_list(max_expanded - 1)>
 $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
+  vtkm::internal::NullType Remaining;
 
   VTK_M_DEVICE VariantUnionNTD(vtkm::internal::NullType) { }
   VariantUnionNTD() = default;
@@ -217,7 +219,6 @@ $endfor\
 template <$typename_list(max_expanded), typename... Ts>
 union VariantUnionTD<$type_list(max_expanded), Ts...>
 {
-  vtkm::internal::NullType Dummy;
 $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
@@ -230,7 +231,6 @@ $endfor\
 template <$typename_list(max_expanded), typename... Ts>
 union VariantUnionNTD<$type_list(max_expanded), Ts...>
 {
-  vtkm::internal::NullType Dummy;
 $for(param_index in range(max_expanded))\
   T$(param_index) V$(param_index);
 $endfor\
@@ -304,64 +304,91 @@ VTK_M_DEVICE auto VariantUnionGet(UnionType& storage) noexcept
   return VariantUnionGetImpl<I, typename std::decay<UnionType>::type>::Get(storage);
 }
 
-// --------------------------------------------------------------------------------
-// Internal implementation of CastAndCall for Variant
-$for(num_params in range(max_expanded))\
-template <typename Functor,
-          typename UnionType,
-          typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, $(num_params + 1)>,
-  vtkm::IdComponent index,
-  Functor&& f,
-  UnionType& storage,
-  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
-{
-  switch (index)
-  {
-$for(param_index in range(num_params + 1))\
-    case $(param_index):
-      return f(storage.V$(param_index), std::forward<Args>(args)...);
-$endfor\
-    default:
-      // If we are here, it means we failed to find the appropriate type in a variant
-      VTKM_ASSERT(false && "Internal error, bad Variant state.");
-      return VariantDummyReturn<decltype(f(storage.V0, args...))>::F();
-  }
-}
-
-$endfor\
 //clang-format on
 
-// Recurse for cases where Variant has more than $(max_expanded) types
-template <vtkm::IdComponent N,
+// --------------------------------------------------------------------------------
+// Internal implementation of CastAndCall for Variant
+template <typename ReturnType,
           typename Functor,
-          typename UnionType,
+          typename CastMember,
           typename... Args>
-VTK_M_DEVICE inline auto VariantCastAndCallImpl(
-  std::integral_constant<vtkm::IdComponent, N>,
+VTK_M_DEVICE inline ReturnType VariantCallFunctor(
+  std::false_type,
+  Functor&& f,
+  CastMember& value,
+  Args&&... args) noexcept(noexcept(f(value, args...)))
+{
+  // If you get a compile error here, it probably means that you have called Variant::CastAndCall
+  // with a functor that does not accept one of the types in the Variant. The functor you provide
+  // must be callable with all types in the Variant, not just the one that it currently holds.
+  return f(value, std::forward<Args>(args)...);
+}
+
+template <typename ReturnType,
+          typename Functor,
+          typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCallFunctor(
+  std::true_type, Functor&&, vtkm::internal::NullType, Args&&...) noexcept
+{
+  // If we are here, it means a Variant had an inappropriate index.
+  VTKM_ASSERT(false && "Internal error, bad Variant state.");
+  return VariantDummyReturn<ReturnType>::F();
+}
+
+// Terminating condition in recursive template
+template <typename ReturnType, typename Functor, typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCastAndCallImplR(
+  std::true_type,
+  vtkm::IdComponent vtkmNotUsed(index),
+  Functor&& vtkmNotUsed(f),
+  vtkm::internal::NullType,
+  Args&&... vtkmNotUsed(args)) noexcept
+{
+  // If we are here, it means a Variant had an inappropriate index.
+  VTKM_ASSERT(false && "Internal error, bad Variant state.");
+  return VariantDummyReturn<ReturnType>::F();
+}
+
+template <typename ReturnType, typename Functor, typename UnionType, typename... Args>
+VTK_M_DEVICE inline ReturnType VariantCastAndCallImplR(
+  std::false_type,
   vtkm::IdComponent index,
   Functor&& f,
   UnionType& storage,
   Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
-  -> decltype(f(storage.V0, args...))
 {
   switch (index)
   {
 $for(param_index in range(max_expanded))\
     case $(param_index):
-      return f(storage.V$(param_index), std::forward<Args>(args)...);
+      return VariantCallFunctor<ReturnType>(
+        typename std::is_same<decltype(storage.V$(param_index)), vtkm::internal::NullType>::type{},
+        std::forward<Functor>(f),
+        storage.V$(param_index),
+        std::forward<Args>(args)...);
 $endfor\
     default:
-      return VariantCastAndCallImpl(std::integral_constant<vtkm::IdComponent, N - $(max_expanded)>{},
-                                    index - $(max_expanded),
-                                    std::forward<Functor>(f),
-                                    storage.Remaining,
-                                    std::forward<Args>(args)...);
+      return VariantCastAndCallImplR<ReturnType>(
+        typename std::is_same<decltype(storage.Remaining), vtkm::internal::NullType>::type{},
+        index - $(max_expanded),
+        std::forward<Functor>(f),
+        storage.Remaining,
+        std::forward<Args>(args)...);
   }
 }
 
+template <typename Functor, typename UnionType, typename... Args>
+VTK_M_DEVICE inline auto VariantCastAndCallImpl(
+  vtkm::IdComponent index,
+  Functor&& f,
+  UnionType& storage,
+  Args&&... args) noexcept(noexcept(f(storage.V0, args...)))
+  -> decltype(f(storage.V0, args...))
+{
+  return VariantCastAndCallImplR<decltype(f(storage.V0, args...))>(
+    std::false_type{}, index, std::forward<Functor>(f), storage, std::forward<Args>(args)...);
+}
+
 }
 }
 }

From 6ccb32d27b6576315968d01b1f6ab65466d650b9 Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Wed, 31 Mar 2021 14:35:06 -0600
Subject: [PATCH 10/11] Slight comment changes

---
 vtkm/internal/VariantImplDetail.h    | 12 +++++++-----
 vtkm/internal/VariantImplDetail.h.in | 12 +++++++-----
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/vtkm/internal/VariantImplDetail.h b/vtkm/internal/VariantImplDetail.h
index 6e9bc3c2b..57a591d2f 100644
--- a/vtkm/internal/VariantImplDetail.h
+++ b/vtkm/internal/VariantImplDetail.h
@@ -216,16 +216,18 @@ struct AllTriviallyDestructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11
 // reinterpret_cast. However, doing that leads to undefined behavior. The C++ compiler assumes that
 // 2 pointers of different types point to different memory (even if it is clear that they are set
 // to the same address). That means optimizers can remove code because it "knows" that data in one
-// type cannot affect data in another type. To safely change the type of an std::aligned_union,
-// you really have to do an std::memcpy. This is problematic for types that cannot be trivially
-// copied. Another problem is that we found that device compilers do not optimize the memcpy
-// as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
+// type cannot affect data in another type. (See Shafik Yaghmour's excellent writeup at
+// https://gist.github.com/shafik/848ae25ee209f698763cffee272a58f8 for more details.) To safely
+// change the type of an std::aligned_union, you really have to do an std::memcpy. This is
+// problematic for types that cannot be trivially copied. Another problem is that we found that
+// device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is
+// used much less frequently on GPU devices.
 //
 // Part of the trickiness of the union implementation is trying to preserve when the type is
 // trivially constructible and copyable. The trick is that if members of the union are not trivial,
 // then the default constructors are deleted. To get around that, a non-default constructor is
 // added, which we can use to construct the union for non-trivial types. Working with types with
-// non-trivial destructors are particularly trick. Again, if any member of the union has a
+// non-trivial destructors are particularly tricky. Again, if any member of the union has a
 // non-trivial destructor, the destructor is deleted. Unlike a constructor, you cannot just say to
 // use a different destructor. Thus, we have to define our own destructor for the union.
 // Technically, the destructor here does not do anything, but the actual destruction should be
diff --git a/vtkm/internal/VariantImplDetail.h.in b/vtkm/internal/VariantImplDetail.h.in
index 39587939e..ef34b33cc 100644
--- a/vtkm/internal/VariantImplDetail.h.in
+++ b/vtkm/internal/VariantImplDetail.h.in
@@ -156,16 +156,18 @@ struct AllTriviallyDestructible<$type_list(max_expanded), Ts...>
 // reinterpret_cast. However, doing that leads to undefined behavior. The C++ compiler assumes that
 // 2 pointers of different types point to different memory (even if it is clear that they are set
 // to the same address). That means optimizers can remove code because it "knows" that data in one
-// type cannot affect data in another type. To safely change the type of an std::aligned_union,
-// you really have to do an std::memcpy. This is problematic for types that cannot be trivially
-// copied. Another problem is that we found that device compilers do not optimize the memcpy
-// as well as most CPU compilers. Likely, memcpy is used much less frequently on GPU devices.
+// type cannot affect data in another type. (See Shafik Yaghmour's excellent writeup at
+// https://gist.github.com/shafik/848ae25ee209f698763cffee272a58f8 for more details.) To safely
+// change the type of an std::aligned_union, you really have to do an std::memcpy. This is
+// problematic for types that cannot be trivially copied. Another problem is that we found that
+// device compilers do not optimize the memcpy as well as most CPU compilers. Likely, memcpy is
+// used much less frequently on GPU devices.
 //
 // Part of the trickiness of the union implementation is trying to preserve when the type is
 // trivially constructible and copyable. The trick is that if members of the union are not trivial,
 // then the default constructors are deleted. To get around that, a non-default constructor is
 // added, which we can use to construct the union for non-trivial types. Working with types with
-// non-trivial destructors are particularly trick. Again, if any member of the union has a
+// non-trivial destructors are particularly tricky. Again, if any member of the union has a
 // non-trivial destructor, the destructor is deleted. Unlike a constructor, you cannot just say to
 // use a different destructor. Thus, we have to define our own destructor for the union.
 // Technically, the destructor here does not do anything, but the actual destruction should be

From 6921b5cc3d17b4abbc351b8fe487614ddb36947d Mon Sep 17 00:00:00 2001
From: Kenneth Moreland <kmorel@sandia.gov>
Date: Thu, 1 Apr 2021 14:47:51 -0600
Subject: [PATCH 11/11] Minor style changes in UnitTestVariant

---
 .../exec/internal/testing/UnitTestVariant.cxx | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/vtkm/exec/internal/testing/UnitTestVariant.cxx b/vtkm/exec/internal/testing/UnitTestVariant.cxx
index fd3040968..83d645764 100644
--- a/vtkm/exec/internal/testing/UnitTestVariant.cxx
+++ b/vtkm/exec/internal/testing/UnitTestVariant.cxx
@@ -236,18 +236,18 @@ void TestTriviallyCopyable()
 {
 #ifdef VTKM_USE_STD_IS_TRIVIAL
   // Make sure base types are behaving as expected
-  VTKM_STATIC_ASSERT(std::is_trivially_constructible<float>::value);
-  VTKM_STATIC_ASSERT(std::is_trivially_copyable<float>::value);
-  VTKM_STATIC_ASSERT(std::is_trivial<float>::value);
-  VTKM_STATIC_ASSERT(std::is_trivially_constructible<int>::value);
-  VTKM_STATIC_ASSERT(std::is_trivially_copyable<int>::value);
-  VTKM_STATIC_ASSERT(std::is_trivial<int>::value);
-  VTKM_STATIC_ASSERT(!std::is_trivially_constructible<NonTrivial>::value);
-  VTKM_STATIC_ASSERT(!std::is_trivially_copyable<NonTrivial>::value);
-  VTKM_STATIC_ASSERT(!std::is_trivial<NonTrivial>::value);
-  VTKM_STATIC_ASSERT(!std::is_trivially_constructible<TrivialCopy>::value);
-  VTKM_STATIC_ASSERT(std::is_trivially_copyable<TrivialCopy>::value);
-  VTKM_STATIC_ASSERT(!std::is_trivial<TrivialCopy>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivially_constructible<float>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivially_copyable<float>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivial<float>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivially_constructible<int>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivially_copyable<int>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivial<int>::value);
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivially_constructible<NonTrivial>::value);
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivially_copyable<NonTrivial>::value);
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivial<NonTrivial>::value);
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivially_constructible<TrivialCopy>::value);
+  VTKM_STATIC_ASSERT(vtkmstd::is_trivially_copyable<TrivialCopy>::value);
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivial<TrivialCopy>::value);
 
   // A variant of trivially constructable things should be trivially constructable
   VTKM_STATIC_ASSERT((vtkmstd::is_trivially_constructible<
@@ -295,7 +295,7 @@ void TestTriviallyCopyable()
     (!vtkmstd::is_trivial<vtkm::exec::internal::Variant<float, int, TrivialCopy>>::value));
   VTKM_STATIC_ASSERT(
     (!vtkmstd::is_trivial<vtkm::exec::internal::Variant<float, int, NonTrivial>>::value));
-#endif // !VTKM_USING_GLIBCXX_4
+#endif // VTKM_USE_STD_IS_TRIVIAL
 }
 
 struct TestFunctor
@@ -450,8 +450,8 @@ void TestCopyDestroy()
                                                     TypePlaceholder<3>,
                                                     TypePlaceholder<4>>;
 #ifdef VTKM_USE_STD_IS_TRIVIAL
-  VTKM_STATIC_ASSERT(!std::is_trivially_copyable<VariantType>::value);
-#endif // !VTKM_USING_GLIBCXX_4
+  VTKM_STATIC_ASSERT(!vtkmstd::is_trivially_copyable<VariantType>::value);
+#endif // VTKM_USE_STD_IS_TRIVIAL
   vtkm::Id count = 0;
 
   VariantType variant1 = CountConstructDestruct(&count);