Remove workarounds for rust-lang/rust#60637

Author: sayantn

crates/core_arch/src/macros.rs

@@ -94,25 +94,15 @@ macro_rules! types {
             /// so use this internal helper for it instead.
             #[inline(always)]
             $v fn splat(value: $elem_type) -> $name {
-                #[derive(Copy, Clone)]
-                #[repr(simd)]
-                struct JustOne([$elem_type; 1]);
-                let one = JustOne([value]);
-                // SAFETY: 0 is always in-bounds because we're shuffling
-                // a simd type with exactly one element.
-                unsafe { simd_shuffle!(one, one, [0; $len]) }
+                $name([value; $len])
             }
 
             /// Returns an array reference containing the entire SIMD vector.
             $v const fn as_array(&self) -> &[$elem_type; $len] {
                 // SAFETY: this type is just an overaligned `[T; N]` with
                 // potential padding at the end, so pointer casting to a
                 // `&[T; N]` is safe.
-                //
-                // NOTE: This deliberately doesn't just use `&self.0` because it may soon be banned
-                // see https://github.com/rust-lang/compiler-team/issues/838
                 unsafe { &*(self as *const Self as *const [$elem_type; $len]) }
-
             }
 
             /// Returns a mutable array reference containing the entire SIMD vector.
@@ -121,9 +111,6 @@ macro_rules! types {
                 // SAFETY: this type is just an overaligned `[T; N]` with
                 // potential padding at the end, so pointer casting to a
                 // `&mut [T; N]` is safe.
-                //
-                // NOTE: This deliberately doesn't just use `&mut self.0` because it may soon be banned
-                // see https://github.com/rust-lang/compiler-team/issues/838
                 unsafe { &mut *(self as *mut Self as *mut [$elem_type; $len]) }
             }
         }

crates/core_arch/src/simd.rs

@@ -21,22 +21,12 @@ macro_rules! simd_ty {
             pub(crate) const fn from_array(elements: [$elem_type; $len]) -> Self {
                 $id(elements)
             }
-            // FIXME: Workaround rust@60637
+            
             #[inline(always)]
             pub(crate) fn splat(value: $elem_type) -> Self {
-                #[derive(Copy, Clone)]
-                #[repr(simd)]
-                struct JustOne([$elem_type; 1]);
-                let one = JustOne([value]);
-                // SAFETY: 0 is always in-bounds because we're shuffling
-                // a simd type with exactly one element.
-                unsafe { simd_shuffle!(one, one, [0; $len]) }
+                $id([value; $len])
             }
 
-            /// Extract the element at position `index`.
-            /// `index` is not a constant so this is not efficient!
-            /// Use for testing only.
-            // FIXME: Workaround rust@60637
             #[inline(always)]
             pub(crate) fn extract(&self, index: usize) -> $elem_type {
                 self.as_array()[index]
@@ -87,16 +77,9 @@ macro_rules! simd_m_ty {
                 $id([$(Self::bool_to_internal($param_name)),*])
             }
 
-            // FIXME: Workaround rust@60637
             #[inline(always)]
             pub(crate) fn splat(value: bool) -> Self {
-                #[derive(Copy, Clone)]
-                #[repr(simd)]
-                struct JustOne([$elem_type; 1]);
-                let one = JustOne([Self::bool_to_internal(value)]);
-                // SAFETY: 0 is always in-bounds because we're shuffling
-                // a simd type with exactly one element.
-                unsafe { simd_shuffle!(one, one, [0; $len]) }
+                $id([Self::bool_to_internal(value); $len])
             }
 
             #[inline]