Stop projecting into SIMD types in ui/simd/ tests

tests/ui/simd/generics.rs

@@ -8,18 +8,30 @@ use std::ops;
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct f32x4([f32; 4]);
+impl f32x4 {
+    fn to_array(self) -> [f32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct A<const N: usize>([f32; N]);
+impl<const N: usize> A<N> {
+    fn to_array(self) -> [f32; N] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct B<T>([T; 4]);
+impl<T> B<T> {
+    fn to_array(self) -> [T; 4] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct C<T, const N: usize>([T; N]);
+impl<T, const N: usize> C<T, N> {
+    fn to_array(self) -> [T; N] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
 
 fn add<T: ops::Add<Output = T>>(lhs: T, rhs: T) -> T {
     lhs + rhs
@@ -63,18 +75,18 @@ pub fn main() {
 
     // lame-o
     let a = f32x4([1.0f32, 2.0f32, 3.0f32, 4.0f32]);
-    let f32x4([a0, a1, a2, a3]) = add(a, a);
+    let [a0, a1, a2, a3] = add(a, a).to_array();
     assert_eq!(a0, 2.0f32);
     assert_eq!(a1, 4.0f32);
     assert_eq!(a2, 6.0f32);
     assert_eq!(a3, 8.0f32);
 
     let a = A(x);
-    assert_eq!(add(a, a).0, y);
+    assert_eq!(add(a, a).to_array(), y);
 
     let b = B(x);
-    assert_eq!(add(b, b).0, y);
+    assert_eq!(add(b, b).to_array(), y);
 
     let c = C(x);
-    assert_eq!(add(c, c).0, y);
+    assert_eq!(add(c, c).to_array(), y);
 }

tests/ui/simd/intrinsic/float-math-pass.rs

@@ -12,8 +12,11 @@
 #![allow(non_camel_case_types)]
 
 #[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone)]
 struct f32x4(pub [f32; 4]);
+impl f32x4 {
+    fn to_array(self) -> [f32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 use std::intrinsics::simd::*;
 
@@ -25,12 +28,12 @@ macro_rules! assert_approx_eq_f32 {
 }
 macro_rules! assert_approx_eq {
     ($a:expr, $b:expr) => {{
-        let a = $a;
-        let b = $b;
-        assert_approx_eq_f32!(a.0[0], b.0[0]);
-        assert_approx_eq_f32!(a.0[1], b.0[1]);
-        assert_approx_eq_f32!(a.0[2], b.0[2]);
-        assert_approx_eq_f32!(a.0[3], b.0[3]);
+        let a = $a.to_array();
+        let b = $b.to_array();
+        assert_approx_eq_f32!(a[0], b[0]);
+        assert_approx_eq_f32!(a[1], b[1]);
+        assert_approx_eq_f32!(a[2], b[2]);
+        assert_approx_eq_f32!(a[3], b[3]);
     }};
 }
 
@@ -77,15 +80,15 @@ fn main() {
 
         // rounding functions
         let r = simd_floor(h);
-        assert_eq!(z, r);
+        assert_eq!(z.to_array(), r.to_array());
 
         let r = simd_ceil(h);
-        assert_eq!(x, r);
+        assert_eq!(x.to_array(), r.to_array());
 
         let r = simd_round(h);
-        assert_eq!(x, r);
+        assert_eq!(x.to_array(), r.to_array());
 
         let r = simd_trunc(h);
-        assert_eq!(z, r);
+        assert_eq!(z.to_array(), r.to_array());
     }
 }

tests/ui/simd/intrinsic/float-minmax-pass.rs

@@ -7,11 +7,22 @@
 #![allow(non_camel_case_types)]
 
 #[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone)]
 struct f32x4(pub [f32; 4]);
+impl f32x4 {
+    fn to_array(self) -> [f32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 use std::intrinsics::simd::*;
 
+macro_rules! all_eq {
+    ($a: expr, $b: expr) => {{
+        let a = $a;
+        let b = $b;
+        assert_eq!(a.to_array(), b.to_array());
+    }};
+}
+
 fn main() {
     let x = f32x4([1.0, 2.0, 3.0, 4.0]);
     let y = f32x4([2.0, 1.0, 4.0, 3.0]);
@@ -28,22 +39,22 @@ fn main() {
     unsafe {
         let min0 = simd_fmin(x, y);
         let min1 = simd_fmin(y, x);
-        assert_eq!(min0, min1);
+        all_eq!(min0, min1);
         let e = f32x4([1.0, 1.0, 3.0, 3.0]);
-        assert_eq!(min0, e);
+        all_eq!(min0, e);
         let minn = simd_fmin(x, n);
-        assert_eq!(minn, x);
+        all_eq!(minn, x);
         let minn = simd_fmin(y, n);
-        assert_eq!(minn, y);
+        all_eq!(minn, y);
 
         let max0 = simd_fmax(x, y);
         let max1 = simd_fmax(y, x);
-        assert_eq!(max0, max1);
+        all_eq!(max0, max1);
         let e = f32x4([2.0, 2.0, 4.0, 4.0]);
-        assert_eq!(max0, e);
+        all_eq!(max0, e);
         let maxn = simd_fmax(x, n);
-        assert_eq!(maxn, x);
+        all_eq!(maxn, x);
         let maxn = simd_fmax(y, n);
-        assert_eq!(maxn, y);
+        all_eq!(maxn, y);
     }
 }

tests/ui/simd/intrinsic/generic-arithmetic-pass.rs

@@ -5,20 +5,29 @@
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct i32x4(pub [i32; 4]);
+impl i32x4 {
+    fn to_array(self) -> [i32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct U32<const N: usize>([u32; N]);
+impl<const N: usize> U32<N> {
+    fn to_array(self) -> [u32; N] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct f32x4(pub [f32; 4]);
+impl f32x4 {
+    fn to_array(self) -> [f32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 macro_rules! all_eq {
     ($a: expr, $b: expr) => {{
         let a = $a;
         let b = $b;
-        assert!(a.0 == b.0);
+        assert!(a.to_array() == b.to_array());
     }};
 }
 

tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs

@@ -7,12 +7,26 @@
 use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 #[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Copy, Clone)]
 struct u32x4(pub [u32; 4]);
+impl u32x4 {
+    fn to_array(self) -> [u32; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct I32<const N: usize>([i32; N]);
+impl<const N: usize> I32<N> {
+    fn to_array(self) -> [i32; N] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
+
+macro_rules! all_eq {
+    ($a: expr, $b: expr) => {{
+        let a = $a;
+        let b = $b;
+        assert_eq!(a.to_array(), b.to_array());
+    }};
+}
 
 fn main() {
     // unsigned
@@ -26,20 +40,20 @@ fn main() {
         let z = u32x4([0, 0, 0, 0]);
 
         unsafe {
-            assert_eq!(simd_saturating_add(z, z), z);
-            assert_eq!(simd_saturating_add(z, a), a);
-            assert_eq!(simd_saturating_add(b, z), b);
-            assert_eq!(simd_saturating_add(a, a), b);
-            assert_eq!(simd_saturating_add(a, m), m);
-            assert_eq!(simd_saturating_add(m, b), m);
-            assert_eq!(simd_saturating_add(m1, a), m);
+            all_eq!(simd_saturating_add(z, z), z);
+            all_eq!(simd_saturating_add(z, a), a);
+            all_eq!(simd_saturating_add(b, z), b);
+            all_eq!(simd_saturating_add(a, a), b);
+            all_eq!(simd_saturating_add(a, m), m);
+            all_eq!(simd_saturating_add(m, b), m);
+            all_eq!(simd_saturating_add(m1, a), m);
 
-            assert_eq!(simd_saturating_sub(b, z), b);
-            assert_eq!(simd_saturating_sub(b, a), a);
-            assert_eq!(simd_saturating_sub(a, a), z);
-            assert_eq!(simd_saturating_sub(a, b), z);
-            assert_eq!(simd_saturating_sub(a, m1), z);
-            assert_eq!(simd_saturating_sub(b, m1), z);
+            all_eq!(simd_saturating_sub(b, z), b);
+            all_eq!(simd_saturating_sub(b, a), a);
+            all_eq!(simd_saturating_sub(a, a), z);
+            all_eq!(simd_saturating_sub(a, b), z);
+            all_eq!(simd_saturating_sub(a, m1), z);
+            all_eq!(simd_saturating_sub(b, m1), z);
         }
     }
 
@@ -61,28 +75,28 @@ fn main() {
         let z = I32::<4>([0, 0, 0, 0]);
 
         unsafe {
-            assert_eq!(simd_saturating_add(z, z).0, z.0);
-            assert_eq!(simd_saturating_add(z, a).0, a.0);
-            assert_eq!(simd_saturating_add(b, z).0, b.0);
-            assert_eq!(simd_saturating_add(a, a).0, b.0);
-            assert_eq!(simd_saturating_add(a, max).0, max.0);
-            assert_eq!(simd_saturating_add(max, b).0, max.0);
-            assert_eq!(simd_saturating_add(max1, a).0, max.0);
-            assert_eq!(simd_saturating_add(min1, z).0, min1.0);
-            assert_eq!(simd_saturating_add(min, z).0, min.0);
-            assert_eq!(simd_saturating_add(min1, c).0, min.0);
-            assert_eq!(simd_saturating_add(min, c).0, min.0);
-            assert_eq!(simd_saturating_add(min1, d).0, min.0);
-            assert_eq!(simd_saturating_add(min, d).0, min.0);
+            all_eq!(simd_saturating_add(z, z), z);
+            all_eq!(simd_saturating_add(z, a), a);
+            all_eq!(simd_saturating_add(b, z), b);
+            all_eq!(simd_saturating_add(a, a), b);
+            all_eq!(simd_saturating_add(a, max), max);
+            all_eq!(simd_saturating_add(max, b), max);
+            all_eq!(simd_saturating_add(max1, a), max);
+            all_eq!(simd_saturating_add(min1, z), min1);
+            all_eq!(simd_saturating_add(min, z), min);
+            all_eq!(simd_saturating_add(min1, c), min);
+            all_eq!(simd_saturating_add(min, c), min);
+            all_eq!(simd_saturating_add(min1, d), min);
+            all_eq!(simd_saturating_add(min, d), min);
 
-            assert_eq!(simd_saturating_sub(b, z).0, b.0);
-            assert_eq!(simd_saturating_sub(b, a).0, a.0);
-            assert_eq!(simd_saturating_sub(a, a).0, z.0);
-            assert_eq!(simd_saturating_sub(a, b).0, c.0);
-            assert_eq!(simd_saturating_sub(z, max).0, min1.0);
-            assert_eq!(simd_saturating_sub(min1, z).0, min1.0);
-            assert_eq!(simd_saturating_sub(min1, a).0, min.0);
-            assert_eq!(simd_saturating_sub(min1, b).0, min.0);
+            all_eq!(simd_saturating_sub(b, z), b);
+            all_eq!(simd_saturating_sub(b, a), a);
+            all_eq!(simd_saturating_sub(a, a), z);
+            all_eq!(simd_saturating_sub(a, b), c);
+            all_eq!(simd_saturating_sub(z, max), min1);
+            all_eq!(simd_saturating_sub(min1, z), min1);
+            all_eq!(simd_saturating_sub(min1, a), min);
+            all_eq!(simd_saturating_sub(min1, b), min);
         }
     }
 }

tests/ui/simd/intrinsic/generic-as.rs

@@ -7,40 +7,43 @@ use std::intrinsics::simd::simd_as;
 #[derive(Copy, Clone)]
 #[repr(simd)]
 struct V<T>([T; 2]);
+impl<T> V<T> {
+    fn to_array(self) -> [T; 2] { unsafe { std::intrinsics::transmute_unchecked(self) } }
+}
 
 fn main() {
     unsafe {
         let u = V::<u32>([u32::MIN, u32::MAX]);
         let i: V<i16> = simd_as(u);
-        assert_eq!(i.0[0], u.0[0] as i16);
-        assert_eq!(i.0[1], u.0[1] as i16);
+        assert_eq!(i.to_array()[0], u.to_array()[0] as i16);
+        assert_eq!(i.to_array()[1], u.to_array()[1] as i16);
     }
 
     unsafe {
         let f = V::<f32>([f32::MIN, f32::MAX]);
         let i: V<i16> = simd_as(f);
-        assert_eq!(i.0[0], f.0[0] as i16);
-        assert_eq!(i.0[1], f.0[1] as i16);
+        assert_eq!(i.to_array()[0], f.to_array()[0] as i16);
+        assert_eq!(i.to_array()[1], f.to_array()[1] as i16);
     }
 
     unsafe {
         let f = V::<f32>([f32::MIN, f32::MAX]);
         let u: V<u8> = simd_as(f);
-        assert_eq!(u.0[0], f.0[0] as u8);
-        assert_eq!(u.0[1], f.0[1] as u8);
+        assert_eq!(u.to_array()[0], f.to_array()[0] as u8);
+        assert_eq!(u.to_array()[1], f.to_array()[1] as u8);
     }
 
     unsafe {
         let f = V::<f64>([f64::MIN, f64::MAX]);
         let i: V<isize> = simd_as(f);
-        assert_eq!(i.0[0], f.0[0] as isize);
-        assert_eq!(i.0[1], f.0[1] as isize);
+        assert_eq!(i.to_array()[0], f.to_array()[0] as isize);
+        assert_eq!(i.to_array()[1], f.to_array()[1] as isize);
     }
 
     unsafe {
         let f = V::<f64>([f64::MIN, f64::MAX]);
         let u: V<usize> = simd_as(f);
-        assert_eq!(u.0[0], f.0[0] as usize);
-        assert_eq!(u.0[1], f.0[1] as usize);
+        assert_eq!(u.to_array()[0], f.to_array()[0] as usize);
+        assert_eq!(u.to_array()[1], f.to_array()[1] as usize);
     }
 }

tests/ui/simd/intrinsic/generic-bswap-byte.rs

@@ -7,14 +7,20 @@ use std::intrinsics::simd::simd_bswap;
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct i8x4([i8; 4]);
+impl i8x4 {
+    fn to_array(self) -> [i8; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct u8x4([u8; 4]);
+impl u8x4 {
+    fn to_array(self) -> [u8; 4] { unsafe { std::mem::transmute(self) } }
+}
 
 fn main() {
     unsafe {
-        assert_eq!(simd_bswap(i8x4([0, 1, 2, 3])).0, [0, 1, 2, 3]);
-        assert_eq!(simd_bswap(u8x4([0, 1, 2, 3])).0, [0, 1, 2, 3]);
+        assert_eq!(simd_bswap(i8x4([0, 1, 2, 3])).to_array(), [0, 1, 2, 3]);
+        assert_eq!(simd_bswap(u8x4([0, 1, 2, 3])).to_array(), [0, 1, 2, 3]);
     }
 }