Correct inefficient extract component for decorating arrays

Many arrays decorate other arrays but still allow an efficient component
extraction. However, the component can only be extracted if it can be
efficiently extracted from the array being decorated. In this case, the
array reported that it could efficiently extract even though it could
not.

Fixed this by having the `ArrayExtractComponentImpl` classes inherit
from the respective superclass. This will in turn inhert the
`ArrayExtractComponentImplInefficient` if it is the base class.

vtkm/cont/ArrayExtractComponent.h

@@ -19,6 +19,8 @@
 #include <vtkm/VecFlat.h>
 #include <vtkm/VecTraits.h>
 
+#include <vtkmstd/integer_sequence.h>
+
 #include <vtkm/cont/vtkm_cont_export.h>
 
 namespace vtkm
@@ -137,6 +139,39 @@ struct ArrayExtractComponentImpl<vtkm::cont::StorageTagBasic>
   }
 };
 
+namespace detail
+{
+
+template <std::size_t, typename Super>
+struct ForwardSuper : Super
+{
+};
+
+template <typename sequence, typename... Supers>
+struct SharedSupersImpl;
+
+template <std::size_t... Indices, typename... Supers>
+struct SharedSupersImpl<vtkmstd::index_sequence<Indices...>, Supers...>
+  : ForwardSuper<Indices, Supers>...
+{
+};
+
+} // namespace detail
+
+// `ArrayExtractComponentImpl`s that modify the behavior from other storage types might
+// want to inherit from the `ArrayExtractComponentImpl`s of these storage types. However,
+// if the template specifies multiple storage types, two of the same might be specified,
+// and it is illegal in C++ to directly inherit from the same type twice. This special
+// superclass accepts a variable amout of superclasses. Inheriting from this will inherit
+// from all these superclasses, and duplicates are allowed.
+template <typename... Supers>
+using DuplicatedSuperclasses =
+  detail::SharedSupersImpl<vtkmstd::make_index_sequence<sizeof...(Supers)>, Supers...>;
+
+template <typename... StorageTags>
+using ArrayExtractComponentImplInherit =
+  DuplicatedSuperclasses<vtkm::cont::internal::ArrayExtractComponentImpl<StorageTags>...>;
+
 /// \brief Resolves to true if ArrayHandleComponent of the array handle would be inefficient.
 ///
 template <typename ArrayHandleType>

vtkm/cont/ArrayHandleCartesianProduct.h

@@ -379,8 +379,11 @@ VTKM_CONT
 namespace internal
 {
 
+// Superclass will inherit the ArrayExtractComponentImplInefficient property if any
+// of the sub-storage are inefficient (thus making everything inefficient).
 template <typename... STs>
 struct ArrayExtractComponentImpl<vtkm::cont::StorageTagCartesianProduct<STs...>>
+  : vtkm::cont::internal::ArrayExtractComponentImplInherit<STs...>
 {
   template <typename T>
   vtkm::cont::ArrayHandleStride<T> AdjustStrideForComponent(

vtkm/cont/ArrayHandleCompositeVector.h

@@ -507,8 +507,11 @@ struct ExtractComponentCompositeVecFunctor
 
 } // namespace detail
 
+// Superclass will inherit the ArrayExtractComponentImplInefficient property if any
+// of the sub-storage are inefficient (thus making everything inefficient).
 template <typename... StorageTags>
 struct ArrayExtractComponentImpl<StorageTagCompositeVec<StorageTags...>>
+  : vtkm::cont::internal::ArrayExtractComponentImplInherit<StorageTags...>
 {
   template <typename VecT>
   auto operator()(

vtkm/cont/ArrayHandleGroupVec.h

@@ -249,9 +249,12 @@ VTKM_CONT vtkm::cont::ArrayHandleGroupVec<ArrayHandleType, NUM_COMPONENTS> make_
 namespace internal
 {
 
+// Superclass will inherit the ArrayExtractComponentImplInefficient property if
+// the sub-storage is inefficient (thus making everything inefficient).
 template <typename ComponentsStorageTag, vtkm::IdComponent NUM_COMPONENTS>
 struct ArrayExtractComponentImpl<
   vtkm::cont::StorageTagGroupVec<ComponentsStorageTag, NUM_COMPONENTS>>
+  : vtkm::cont::internal::ArrayExtractComponentImpl<ComponentsStorageTag>
 {
   template <typename T>
   vtkm::cont::ArrayHandleStride<typename vtkm::VecTraits<T>::BaseComponentType> operator()(

vtkm/cont/ArrayHandleReverse.h

@@ -217,8 +217,11 @@ VTKM_CONT ArrayHandleReverse<HandleType> make_ArrayHandleReverse(const HandleTyp
 namespace internal
 {
 
+// Superclass will inherit the ArrayExtractComponentImplInefficient property if
+// the sub-storage is inefficient (thus making everything inefficient).
 template <typename StorageTag>
 struct ArrayExtractComponentImpl<vtkm::cont::StorageTagReverse<StorageTag>>
+  : vtkm::cont::internal::ArrayExtractComponentImpl<StorageTag>
 {
   template <typename T>
   using StrideArrayType =

vtkm/cont/ArrayHandleView.h

@@ -258,8 +258,11 @@ ArrayHandleView<ArrayHandleType> make_ArrayHandleView(const ArrayHandleType& arr
 namespace internal
 {
 
+// Superclass will inherit the ArrayExtractComponentImplInefficient property if
+// the sub-storage is inefficient (thus making everything inefficient).
 template <typename StorageTag>
 struct ArrayExtractComponentImpl<StorageTagView<StorageTag>>
+  : vtkm::cont::internal::ArrayExtractComponentImpl<StorageTag>
 {
   template <typename T>
   using StrideArrayType =