[simd] Resolve LWG4420 and LWG4393

Author: mattkretz

source/numerics.tex

@@ -16232,6 +16232,12 @@
     bool_constant<T() == T::value>::value &&
     bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;
 
+template<class From, class To>
+  concept @\defexposconceptnc{explicitly-convertible-to}@ =                                // \expos
+    requires {
+      static_cast<To>(declval<From>());
+    };
+
 template<class T> using @\exposidnc{deduced-vec-t} = \seebelownc@;                   // \expos
 
 template<class V, class T> using @\exposidnc{make-compatible-simd-t} = \seebelownc@; // \expos
@@ -16576,54 +16582,46 @@
                              flags<Flags...> f = {});
 
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-    requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+    requires ranges::@\libconcept{sized_range}@<R>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
                                    flags<Flags...> f = {});
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-    requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+    requires ranges::@\libconcept{sized_range}@<R>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
       const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
                                    iter_difference_t<I> n, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first,
       iter_difference_t<I> n, const typename basic_vec<T, Abi>::mask_type& mask,
       flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
                                    flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
       const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-    requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+    requires ranges::@\libconcept{sized_range}@<R>
     constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
                                  flags<Flags...> f = {});
   template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-    requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+    requires ranges::@\libconcept{sized_range}@<R>
     constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
       const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void partial_store(
       const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void partial_store(
       const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
       const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
                                  flags<Flags...> f = {});
   template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-    requires @\libconcept{indirectly_writable}@<I, T>
     constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
       const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 
@@ -17747,7 +17745,12 @@
 \begin{itemdescr}
 \pnum
 \constraints
-\tcode{\exposid{simd-size-v}<U, UAbi> == size()} is \tcode{true}.
+\begin{itemize}
+ \item
+  \tcode{\exposid{simd-size-v}<U, UAbi> == size()} is \tcode{true}, and
+ \item
+  \tcode{U} satisfies \tcode{exposconcept{explicitly-convertible-to}<T>}.
+\end{itemize}
 
 \pnum
 \effects
@@ -17819,20 +17822,17 @@
 \begin{itemize}
 \item \tcode{R} models \tcode{ranges::\libconcept{contiguous_range}} and
   \tcode{ranges::\libconcept{sized_range}},
-\item \tcode{ranges::size(r)} is a constant expression, and
-\item \tcode{ranges::size(r)} is equal to \tcode{size()}.
+\item \tcode{ranges::size(r)} is a constant expression,
+\item \tcode{ranges::size(r)} is equal to \tcode{size()}, and
+\item \tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
+  \tcode{\exposconcept{explicitly-convertible-to}<T>}.
 \end{itemize}
 
 \pnum
 \mandates
-\begin{itemize}
- \item
-   \tcode{ranges::range_value_t<R>} is a vectorizable type, and
- \item
-  if the template parameter pack \tcode{Flags} does not contain
-  \tcode{\exposid{convert-flag}}, then the conversion from
-  \tcode{ranges::range_value_t<R>} to \tcode{value_type} is value-preserving.
-\end{itemize}
+If the template parameter pack \tcode{Flags} does not contain
+\tcode{\exposid{convert-flag}}, then the conversion from
+\tcode{ranges::range_value_t<R>} to \tcode{value_type} is value-preserving.
 
 \pnum
 \expects
@@ -18575,7 +18575,8 @@
 \mandates
 \begin{itemize}
  \item
-   \tcode{ranges::range_value_t<R>} is a vectorizable type,
+   \tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
+   \tcode{\exposconcept{explicitly-convertible-to}<T>},
  \item
    \tcode{same_as<remove_cvref_t<V>, V>} is \tcode{true},
  \item
@@ -18622,26 +18623,22 @@
 \indexlibrarymember{unchecked_store}{simd}
 \begin{itemdecl}
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-  requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+  requires ranges::@\libconcept{sized_range}@<R>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-  requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+  requires ranges::@\libconcept{sized_range}@<R>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, R&& r,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
                                  flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
                                  flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void unchecked_store(const basic_vec<T, Abi>& v, I first, S last,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 \end{itemdecl}
@@ -18688,26 +18685,22 @@
 \indexlibrarymember{partial_store}{simd}
 \begin{itemdecl}
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-  requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+  requires ranges::@\libconcept{sized_range}@<R>
   constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r, flags<Flags...> f = {});
 template<class T, class Abi, ranges::@\libconcept{contiguous_range}@ R, class... Flags>
-  requires ranges::@\libconcept{sized_range}@<R> && @\libconcept{indirectly_writable}@<ranges::iterator_t<R>, T>
+  requires ranges::@\libconcept{sized_range}@<R>
   constexpr void partial_store(const basic_vec<T, Abi>& v, R&& r,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
                                flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void partial_store(const basic_vec<T, Abi>& v, I first, iter_difference_t<I> n,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
                                flags<Flags...> f = {});
 template<class T, class Abi, @\libconcept{contiguous_iterator}@ I, @\libconcept{sized_sentinel_for}@<I> S, class... Flags>
-  requires @\libconcept{indirectly_writable}@<I, T>
   constexpr void partial_store(const basic_vec<T, Abi>& v, I first, S last,
     const typename basic_vec<T, Abi>::mask_type& mask, flags<Flags...> f = {});
 \end{itemdecl}
@@ -18728,6 +18721,17 @@
    parameter.
 \end{itemize}
 
+\pnum
+\constraints
+\begin{itemize}
+ \item
+   \tcode{ranges::iterator_t<R>} satisfies
+   \tcode{\libconcept{indirectly_writable}<ranges::range_value_t<R>>}, and
+ \item
+   \tcode{T} satisfies
+   \tcode{\exposconcept{explicitly-convertible-to}<ranges::range_value_t<R>>}.
+\end{itemize}
+
 \pnum
 \mandates
 \begin{itemize}
@@ -18763,7 +18767,7 @@
 \effects
 For all $i$ in the range of \range{0}{basic_vec<T, Abi>::size()}, if
 \tcode{mask[$i$] \&\& $i$ < ranges::\brk{}size(r)} is \tcode{true}, evaluates
-\tcode{ranges::data(r)[$i$] = v[$i$]}.
+\tcode{ranges::data(r)[$i$] = static_cast<ranges::range_value_t<R>>(v[$i$])}.
 \end{itemdescr}
 
 \rSec3[simd.permute.static]{Static permute}
@@ -18995,6 +18999,11 @@
   \tcode{T} be \tcode{typename V::value_type}.
 \end{itemize}
 
+\pnum
+\constraints
+\tcode{ranges::range_value_t<R>} is a vectorizable type and satisfies
+\tcode{\exposconcept{explicitly-convertible-to}<T>}.
+
 \pnum
 \mandates
 \begin{itemize}
@@ -19086,7 +19095,16 @@
 
 \pnum
 \constraints
-\tcode{V::size() == I::size()} is \tcode{true}.
+\begin{itemize}
+ \item
+   \tcode{V::size() == I::size()} is \tcode{true},
+ \item
+   \tcode{ranges::iterator_t<R>} satisfies
+   \tcode{\libconcept{indirectly_writable}<ranges::range_value_t<R>>}, and
+ \item
+   \tcode{typename V::value_type} satisfies
+   \tcode{\exposconcept{explicitly-convertible-to}<ranges::range_value_t<R>>}.
+\end{itemize}
 
 \pnum
 \mandates