Make the RHS splats parametric

Author: workingjubilee

crates/core_simd/src/ops.rs

@@ -7,6 +7,7 @@ use core::ops::{Shr, Shl};
 
 mod assign;
 mod deref;
+mod splat;
 mod unary;
 
 impl<I, T, const LANES: usize> core::ops::Index<I> for Simd<T, LANES>
@@ -119,20 +120,6 @@ macro_rules! impl_op {
             }
         }
 
-        impl_ref_ops! {
-            impl<const LANES: usize> core::ops::$trait<$scalar> for Simd<$scalar, LANES>
-            where
-                LaneCount<LANES>: SupportedLaneCount,
-            {
-                type Output = Self;
-
-                #[inline]
-                fn $trait_fn(self, rhs: $scalar) -> Self::Output {
-                    core::ops::$trait::$trait_fn(self, Self::splat(rhs))
-                }
-            }
-        }
-
         impl_ref_ops! {
             impl<const LANES: usize> core::ops::$trait<Simd<$scalar, LANES>> for $scalar
             where
@@ -202,29 +189,6 @@ macro_rules! impl_unsigned_int_ops {
                 }
             }
 
-            impl_ref_ops! {
-                impl<const LANES: usize> core::ops::Div<$scalar> for Simd<$scalar, LANES>
-                where
-                    LaneCount<LANES>: SupportedLaneCount,
-                {
-                    type Output = Self;
-
-                    #[inline]
-                    fn div(self, rhs: $scalar) -> Self::Output {
-                        if rhs == 0 {
-                            panic!("attempt to divide by zero");
-                        }
-                        if <$scalar>::MIN != 0 &&
-                            self.as_array().iter().any(|x| *x == <$scalar>::MIN) &&
-                            rhs == -1 as _ {
-                                panic!("attempt to divide with overflow");
-                        }
-                        let rhs = Self::splat(rhs);
-                        unsafe { intrinsics::simd_div(self, rhs) }
-                    }
-                }
-            }
-
             impl_ref_ops! {
                 impl<const LANES: usize> core::ops::Div<Simd<$scalar, LANES>> for $scalar
                 where
@@ -268,29 +232,6 @@ macro_rules! impl_unsigned_int_ops {
                 }
             }
 
-            impl_ref_ops! {
-                impl<const LANES: usize> core::ops::Rem<$scalar> for Simd<$scalar, LANES>
-                where
-                    LaneCount<LANES>: SupportedLaneCount,
-                {
-                    type Output = Self;
-
-                    #[inline]
-                    fn rem(self, rhs: $scalar) -> Self::Output {
-                        if rhs == 0 {
-                            panic!("attempt to calculate the remainder with a divisor of zero");
-                        }
-                        if <$scalar>::MIN != 0 &&
-                            self.as_array().iter().any(|x| *x == <$scalar>::MIN) &&
-                            rhs == -1 as _ {
-                                panic!("attempt to calculate the remainder with overflow");
-                        }
-                        let rhs = Self::splat(rhs);
-                        unsafe { intrinsics::simd_rem(self, rhs) }
-                    }
-                }
-            }
-
             impl_ref_ops! {
                 impl<const LANES: usize> core::ops::Rem<Simd<$scalar, LANES>> for $scalar
                 where
@@ -328,24 +269,6 @@ macro_rules! impl_unsigned_int_ops {
                 }
             }
 
-            impl_ref_ops! {
-                impl<const LANES: usize> core::ops::Shl<$scalar> for Simd<$scalar, LANES>
-                where
-                    LaneCount<LANES>: SupportedLaneCount,
-                {
-                    type Output = Self;
-
-                    #[inline]
-                    fn shl(self, rhs: $scalar) -> Self::Output {
-                        if invalid_shift_rhs(rhs) {
-                            panic!("attempt to shift left with overflow");
-                        }
-                        let rhs = Self::splat(rhs);
-                        unsafe { intrinsics::simd_shl(self, rhs) }
-                    }
-                }
-            }
-
             impl_ref_ops! {
                 impl<const LANES: usize> core::ops::Shr<Self> for Simd<$scalar, LANES>
                 where
@@ -367,24 +290,6 @@ macro_rules! impl_unsigned_int_ops {
                     }
                 }
             }
-
-            impl_ref_ops! {
-                impl<const LANES: usize> core::ops::Shr<$scalar> for Simd<$scalar, LANES>
-                where
-                    LaneCount<LANES>: SupportedLaneCount,
-                {
-                    type Output = Self;
-
-                    #[inline]
-                    fn shr(self, rhs: $scalar) -> Self::Output {
-                        if invalid_shift_rhs(rhs) {
-                            panic!("attempt to shift with overflow");
-                        }
-                        let rhs = Self::splat(rhs);
-                        unsafe { intrinsics::simd_shr(self, rhs) }
-                    }
-                }
-            }
         )*
     };
 }

crates/core_simd/src/ops/splat.rs

@@ -0,0 +1,75 @@
+//! This module implements "auto-splats" for operators.
+//! These should be handled with care due to the risks to type inference.
+//! We require for every autosplat that:
+//! - Simd<T, _> implements the operation for itself, returning Simd<T, _>
+//! - T implements the same operation for T, returning T
+//! 
+//! The second bound is not strictly necessary, but enforces symmetry
+//! between a vector operation and repeating the scalar equivalent.
+use super::*;
+
+macro_rules! autosplat_rhs {
+    ($(impl<T, const LANES: usize> $op:ident<$operand:ty> for Simd<$scalar:ty, LANES> {
+        fn $call:ident
+    })*) => {
+        $(impl<T, const LANES: usize> $op<$operand> for Simd<$scalar, LANES>
+        where
+            Self: $op<Self, Output=Self>,
+            $operand: SimdElement + $op<T, Output=T>,
+            LaneCount<LANES>: SupportedLaneCount,
+        {
+            type Output = Self;
+
+            #[inline]
+            #[must_use = "operator returns a new vector without mutating the inputs"]
+            fn $call(self, rhs: $operand) -> Self::Output {
+                self.$call(Self::splat(rhs))
+            }
+        })*
+    }
+}
+
+
+autosplat_rhs! {
+    // Arithmetic
+    impl<T, const LANES: usize> Add<T> for Simd<T, LANES> {
+        fn add
+    }
+
+    impl<T, const LANES: usize> Mul<T> for Simd<T, LANES> {
+        fn mul
+    }
+
+    impl<T, const LANES: usize> Sub<T> for Simd<T, LANES> {
+        fn sub
+    }
+
+    impl<T, const LANES: usize> Div<T> for Simd<T, LANES> {
+        fn div
+    }
+
+    impl<T, const LANES: usize> Rem<T> for Simd<T, LANES> {
+        fn rem
+    }
+
+    // Bitwise
+    impl<T, const LANES: usize> BitAnd<T> for Simd<T, LANES> {
+        fn bitand
+    }
+
+    impl<T, const LANES: usize> BitOr<T> for Simd<T, LANES> {
+        fn bitor
+    }
+
+    impl<T, const LANES: usize> BitXor<T> for Simd<T, LANES> {
+        fn bitxor
+    }
+
+    impl<T, const LANES: usize> Shl<T> for Simd<T, LANES> {
+        fn shl
+    }
+
+    impl<T, const LANES: usize> Shr<T> for Simd<T, LANES> {
+        fn shr
+    }
+}