Fixup import pathing for core

This changes simd_swizzle! to a decl_macro to give it a path,
so it can be imported using a path and not the crate root.
It also adds various uses that were missed, adjusts paths,
and exposes some details to make it easier to pass CI.

Author: workingjubilee

crates/core_simd/examples/matrix_inversion.rs

@@ -2,8 +2,8 @@
 // Code ported from the `packed_simd` crate
 // Run this code with `cargo test --example matrix_inversion`
 #![feature(array_chunks, portable_simd)]
-use core_simd::Which::*;
-use core_simd::*;
+use core_simd::simd::*;
+use Which::*;
 
 // Gotta define our own 4x4 matrix since Rust doesn't ship multidim arrays yet :^)
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]

crates/core_simd/src/lib.rs

@@ -1,7 +1,7 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 #![feature(
     const_fn_trait_bound,
-    const_panic,
+    decl_macro,
     platform_intrinsics,
     repr_simd,
     simd_ffi,

crates/core_simd/src/masks.rs

@@ -18,18 +18,22 @@ use core::fmt;
 
 /// Marker trait for types that may be used as SIMD mask elements.
 pub unsafe trait MaskElement: SimdElement {
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper function. Before stabilizing
+    /// this trait, it should be erased from public access.
     fn valid<const LANES: usize>(values: Simd<Self, LANES>) -> bool
     where
         LaneCount<LANES>: SupportedLaneCount;
 
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper function. Before stabilizing
+    /// this trait, it should be erased from public access.
     fn eq(self, other: Self) -> bool;
 
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper const. Before stabilizing
+    /// this trait, it should be erased from public access.
     const TRUE: Self;
 
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper const. Before stabilizing
+    /// this trait, it should be erased from public access.
     const FALSE: Self;
 }
 

crates/core_simd/src/select.rs

@@ -8,7 +8,8 @@ use sealed::Sealed;
 
 /// Supporting trait for vector `select` function
 pub trait Select<Mask>: Sealed {
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper function. Before stabilizing
+    /// this trait, it should be erased from public access.
     fn select(mask: Mask, true_values: Self, false_values: Self) -> Self;
 }
 
@@ -24,6 +25,8 @@ where
     T: SimdElement,
     LaneCount<LANES>: SupportedLaneCount,
 {
+    /// This is supposed to be a hidden helper function. Before stabilizing
+    /// this trait, it should be erased from public access.
     #[inline]
     fn select(mask: Mask<T::Mask, LANES>, true_values: Self, false_values: Self) -> Self {
         unsafe { intrinsics::simd_select(mask.to_int(), true_values, false_values) }
@@ -42,7 +45,8 @@ where
     T: MaskElement,
     LaneCount<LANES>: SupportedLaneCount,
 {
-    #[doc(hidden)]
+    /// This is supposed to be a hidden helper function. Before stabilizing
+    /// this trait, it should be erased from public access.
     #[inline]
     fn select(mask: Self, true_values: Self, false_values: Self) -> Self {
         mask & true_values | !mask & false_values

crates/core_simd/src/swizzle.rs

@@ -1,5 +1,5 @@
 use crate::simd::intrinsics;
-use crate::{LaneCount, Simd, SimdElement, SupportedLaneCount};
+use crate::simd::{LaneCount, Simd, SimdElement, SupportedLaneCount};
 
 /// Constructs a new vector by selecting values from the lanes of the source vector or vectors to use.
 ///
@@ -12,7 +12,8 @@ use crate::{LaneCount, Simd, SimdElement, SupportedLaneCount};
 /// ## One source vector
 /// ```
 /// # #![feature(portable_simd)]
-/// # use core_simd::{Simd, simd_swizzle};
+/// # #[cfg(feature = "std")] use core_simd::{Simd, simd_swizzle};
+/// # #[cfg(not(feature = "std"))] use core::simd::{Simd, simd_swizzle};
 /// let v = Simd::<f32, 4>::from_array([0., 1., 2., 3.]);
 ///
 /// // Keeping the same size
@@ -27,7 +28,8 @@ use crate::{LaneCount, Simd, SimdElement, SupportedLaneCount};
 /// ## Two source vectors
 /// ```
 /// # #![feature(portable_simd)]
-/// # use core_simd::{Simd, simd_swizzle, Which};
+/// # #[cfg(feature = "std")] use core_simd::{Simd, simd_swizzle, Which};
+/// # #[cfg(not(feature = "std"))] use core::simd::{Simd, simd_swizzle, Which};
 /// use Which::*;
 /// let a = Simd::<f32, 4>::from_array([0., 1., 2., 3.]);
 /// let b = Simd::<f32, 4>::from_array([4., 5., 6., 7.]);
@@ -40,11 +42,11 @@ use crate::{LaneCount, Simd, SimdElement, SupportedLaneCount};
 /// let r = simd_swizzle!(a, b, [First(0), Second(0)]);
 /// assert_eq!(r.to_array(), [0., 4.]);
 /// ```
-#[macro_export]
-macro_rules! simd_swizzle {
-    {
+#[allow(unused_macros)]
+pub macro simd_swizzle {
+    (
         $vector:expr, $index:expr $(,)?
-    } => {
+    ) => {
         {
             use $crate::simd::Swizzle;
             struct Impl;
@@ -53,10 +55,10 @@ macro_rules! simd_swizzle {
             }
             Impl::swizzle($vector)
         }
-    };
-    {
+    },
+    (
         $first:expr, $second:expr, $index:expr $(,)?
-    } => {
+    ) => {
         {
             use $crate::simd::{Which, Swizzle2};
             struct Impl;
@@ -262,7 +264,8 @@ where
     ///
     /// ```
     /// #![feature(portable_simd)]
-    /// # use core_simd::Simd;
+    /// # #[cfg(feature = "std")] use core_simd::Simd;
+    /// # #[cfg(not(feature = "std"))] use core::simd::Simd;
     /// let a = Simd::from_array([0, 1, 2, 3]);
     /// let b = Simd::from_array([4, 5, 6, 7]);
     /// let (x, y) = a.interleave(b);
@@ -324,7 +327,8 @@ where
     ///
     /// ```
     /// #![feature(portable_simd)]
-    /// # use core_simd::Simd;
+    /// # #[cfg(feature = "std")] use core_simd::Simd;
+    /// # #[cfg(not(feature = "std"))] use core::simd::Simd;
     /// let a = Simd::from_array([0, 4, 1, 5]);
     /// let b = Simd::from_array([2, 6, 3, 7]);
     /// let (x, y) = a.deinterleave(b);