More cleanup

Signed-off-by: Christian Trott <crtrott@sandia.gov>

Author: crtrott

include/experimental/__p2630_bits/submdspan_canonicalize_slices.hpp

@@ -74,7 +74,7 @@ MDSPAN_TEMPLATE_REQUIRES(
 )
 MDSPAN_INLINE_FUNCTION
 constexpr auto index_cast(OtherIndexType&& i) noexcept {
-  return static_cast<IndexType>(i);
+  return static_cast<IndexType>(std::forward<OtherIndexType>(i));
 }
 
 // ============================================================
@@ -91,6 +91,8 @@ MDSPAN_INLINE_FUNCTION
 constexpr auto canonical_index([[maybe_unused]] S s) {
   // TODO: might move to public semi/public only to get error earlier, and
   // don't duplicate check
+  // TODO: add mandate for integral-constant-like representable as IndexType
+  // TODO: add precondition check that index-cast is representable as IndexType
   static_assert(std::is_signed_v<IndexType> || std::is_unsigned_v<IndexType>);
   if constexpr (is_integral_constant_like_v<S>) {
     return cw<static_cast<IndexType>(index_cast<IndexType>(S::value))>;
@@ -119,108 +121,61 @@ constexpr auto subtract_ice([[maybe_unused]] X x, [[maybe_unused]] Y y) {
   }
 }
 
-// ============================================================
-// check_static_bounds_result: result of a compile-time bounds check
-// ============================================================
-
-enum class check_static_bounds_result {
-  in_bounds,
-  out_of_bounds,
-  unknown
-};
-
-// ============================================================
-// is_std_complex: detect std::complex (for pre-tuple-like compilers)
-// ============================================================
-
-// Clang 21.0.0 does not define __cpp_lib_tuple_like, so it does not
-// support the tuple protocol for std::complex.  Interestingly, it permits
-// structured binding, but decomposes it into one element, not two.
-// We work around with a special canonicalization case.
-#if ! defined(__cpp_lib_tuple_like) || (__cpp_lib_tuple_like < 202311L)
-template<class T>
-constexpr bool is_std_complex = false;
-template<class T>
-constexpr bool is_std_complex<std::complex<T>> = true;
-#endif
-
 // ============================================================
 // check_static_bounds: compile-time bounds check for a slice
 //
-// Returns whether the k-th slice is statically in bounds,
-// out of bounds, or unknown (dynamic bounds or dynamic slice values).
+// Returns false if the slice is statically out of bounds.
 //
 // This function is called only in static_assert contexts.
 // ============================================================
 
-template<size_t k, class S_k, class IndexType, size_t... Exts>
-constexpr check_static_bounds_result check_static_bounds(
-  const extents<IndexType, Exts...>&)
+template<class IndexType, size_t Exts_k, class S_k>
+constexpr bool check_static_bounds()
 {
-#if defined(__cpp_pack_indexing)
-  constexpr size_t Exts_k = Exts...[k];
-#else
-  constexpr size_t Exts_k = [] () {
-    size_t result = 0;
-    size_t i = 0;
-    (void) ((i++ == k ? (result = Exts, true) : false) || ...);
-    return result;
-  } ();
-#endif
-
   if constexpr (std::is_convertible_v<S_k, full_extent_t>) {
-    return check_static_bounds_result::in_bounds;
+    return true;
   }
   else if constexpr (std::is_convertible_v<S_k, IndexType>) {
     if constexpr (is_integral_constant_like_v<S_k>) {
       if constexpr (de_ice(S_k{}) < 0) {
-        return check_static_bounds_result::out_of_bounds;
+        return false;
       }
       else if constexpr (
         Exts_k != dynamic_extent &&
         Exts_k <= static_cast<size_t>(de_ice(S_k{})))
       {
-        return check_static_bounds_result::out_of_bounds;
-      }
-      else if constexpr (
-        Exts_k != dynamic_extent &&
-        static_cast<size_t>(de_ice(S_k{})) < Exts_k)
-      {
-        return check_static_bounds_result::in_bounds;
-      }
-      else {
-        return check_static_bounds_result::unknown;
+        return false;
       }
-    }
-    else {
-      return check_static_bounds_result::unknown;
+      else { return true; }
+    } else {
+      return true;
     }
   }
   else if constexpr (is_strided_slice<S_k>::value) {
     using offset_type = typename S_k::offset_type;
 
     if constexpr (is_integral_constant_like_v<offset_type>) {
       if constexpr (de_ice(offset_type{}) < 0) {
-        return check_static_bounds_result::out_of_bounds;
+        return false;
       }
       else if constexpr (
         Exts_k != dynamic_extent &&
         Exts_k < static_cast<size_t>(de_ice(offset_type{})))
       {
-        return check_static_bounds_result::out_of_bounds;
+        return false;
       }
       else if constexpr (is_integral_constant_like_v<typename S_k::extent_type>) {
         using extent_type = typename S_k::extent_type;
 
         if constexpr (de_ice(offset_type{}) + de_ice(extent_type{}) < 0) {
-          return check_static_bounds_result::out_of_bounds;
+          return false;
         }
         else if constexpr (
           Exts_k != dynamic_extent &&
           Exts_k <
             static_cast<size_t>(de_ice(offset_type{}) + de_ice(extent_type{})))
         {
-          return check_static_bounds_result::out_of_bounds;
+          return false;
         }
         else if constexpr (
           Exts_k != dynamic_extent &&
@@ -230,29 +185,25 @@ constexpr check_static_bounds_result check_static_bounds(
           static_cast<size_t>(
             de_ice(offset_type{}) + de_ice(extent_type{})) <= Exts_k)
         {
-          return check_static_bounds_result::in_bounds;
+          return true;
         }
         else {
-          return check_static_bounds_result::unknown;
+          return true;
         }
       }
       else {
-        return check_static_bounds_result::unknown;
+        return true;
       }
     }
     else {
-      return check_static_bounds_result::unknown;
+      return true;
     }
-  }
-#if ! defined(__cpp_lib_tuple_like) || (__cpp_lib_tuple_like < 202311L)
-  else if constexpr (is_std_complex<S_k>) {
-    return check_static_bounds_result::unknown;
-  }
-#endif
-  else {
+  } else {
     // General pair-like case: attempt to get the first and second elements.
     // If S_k cannot be structured-bound into two elements, this is ill-formed,
     // which implements the Mandates clause.
+    // Doing this via these lambdas since we can do the declval only in a
+    // non-evaluated context
     auto get_first = [] (S_k s_k) {
       auto [s_k0, _x] = s_k;
       return s_k0;
@@ -263,44 +214,45 @@ constexpr check_static_bounds_result check_static_bounds(
     };
     using S_k0 = decltype(get_first(std::declval<S_k>()));
     using S_k1 = decltype(get_second(std::declval<S_k>()));
+
     if constexpr (is_integral_constant_like_v<S_k0>) {
       if constexpr (de_ice(S_k0{}) < 0) {
-        return check_static_bounds_result::out_of_bounds;
+        return false;
       }
       else if constexpr (
         Exts_k != dynamic_extent &&
         Exts_k < static_cast<size_t>(de_ice(S_k0{})))
       {
-        return check_static_bounds_result::out_of_bounds;
+        return false;
       }
       else if constexpr (is_integral_constant_like_v<S_k1>) {
         if constexpr (de_ice(S_k1{}) < de_ice(S_k0{})) {
-          return check_static_bounds_result::out_of_bounds;
+          return false;
         }
         else if constexpr (
           Exts_k != dynamic_extent &&
           Exts_k < static_cast<size_t>(de_ice(S_k1{})))
         {
-          return check_static_bounds_result::out_of_bounds;
+          return false;
         }
         else if constexpr (
           Exts_k != dynamic_extent &&
           0 <= de_ice(S_k0{}) &&
           de_ice(S_k0{}) <= de_ice(S_k1{}) &&
           static_cast<size_t>(de_ice(S_k1{})) <= Exts_k)
         {
-          return check_static_bounds_result::in_bounds;
+          return true;
         }
         else {
-          return check_static_bounds_result::unknown;
+          return true;
         }
       }
       else {
-        return check_static_bounds_result::unknown;
+        return true;
       }
     }
     else {
-      return check_static_bounds_result::unknown;
+      return true;
     }
   }
 }
@@ -313,32 +265,13 @@ constexpr check_static_bounds_result check_static_bounds(
 // mandate checking and canonicalization are distinct concerns.
 // ============================================================
 
-template<size_t k, class IndexType, size_t... Extents, class Slice>
+template<class IndexType, size_t Extent, class Slice>
 MDSPAN_INLINE_FUNCTION
-constexpr void check_submdspan_slice_mandate(
-  const extents<IndexType, Extents...>&,
-  [[maybe_unused]] Slice)
+constexpr bool check_submdspan_slice_mandate(
+  [[maybe_unused]] const Slice&)
 {
-  static_assert(
-    check_static_bounds<k, Slice>(extents<IndexType, Extents...>{}) !=
-    check_static_bounds_result::out_of_bounds);
-}
-
-// ============================================================
-// check_submdspan_slice_mandates: mandate check for all slices
-//
-// Calls check_submdspan_slice_mandate for each slice.
-// Separated from canonicalization so mandate checking is explicit.
-// ============================================================
-
-template<size_t... Inds, class IndexType, size_t... Extents, class... Slices>
-MDSPAN_INLINE_FUNCTION
-constexpr void check_submdspan_slice_mandates(
-  std::index_sequence<Inds...>,
-  const extents<IndexType, Extents...>& exts,
-  Slices... slices)
-{
-  (check_submdspan_slice_mandate<Inds>(exts, slices), ...);
+  static_assert(check_static_bounds<IndexType, Extent, Slice>());
+  return true;
 }
 
 // ============================================================
@@ -404,25 +337,23 @@ constexpr auto canonical_slice([[maybe_unused]] Slice s)
 
 MDSPAN_TEMPLATE_REQUIRES(
   size_t... Inds,
-  class IndexType,
-  size_t... Extents,
+  class Extents,
   class... Slices,
-  /* requires */ (sizeof...(Slices) == sizeof...(Extents))
+  /* requires */ (sizeof...(Slices) == Extents::rank())
 )
 MDSPAN_INLINE_FUNCTION
 constexpr auto canonical_slices_impl(
   std::index_sequence<Inds...>,
-  const extents<IndexType, Extents...>& exts,
+  const Extents&,
   Slices... slices)
 {
   // Mandate checks (static_asserts only, no computation).
   // Separated from canonicalization for clarity.
-  check_submdspan_slice_mandates(
-    std::make_index_sequence<sizeof...(Slices)>(), exts, slices...);
+  (void)(check_submdspan_slice_mandate<typename Extents::index_type, Extents::static_extent(Inds)>(slices) && ... && true);
 
   // Actual canonicalization: returns detail::tuple for device compatibility.
   return detail::tuple{
-    canonical_slice<IndexType>(slices)...
+    canonical_slice<typename Extents::index_type>(slices)...
   };
 }