diff --git a/crates/core_simd/src/masks.rs b/crates/core_simd/src/masks.rs
index ceefbfc94447..1fc281a310d3 100644
--- a/crates/core_simd/src/masks.rs
+++ b/crates/core_simd/src/masks.rs
@@ -43,31 +43,31 @@ macro_rules! define_mask {
 }
 
 define_mask! {
-    #[doc = "8-bit mask"]
+    /// 8-bit mask
     struct mask8(i8);
 }
 
 define_mask! {
-    #[doc = "16-bit mask"]
+    /// 16-bit mask
     struct mask16(i16);
 }
 
 define_mask! {
-    #[doc = "32-bit mask"]
+    /// 32-bit mask
     struct mask32(i32);
 }
 
 define_mask! {
-    #[doc = "64-bit mask"]
+    /// 64-bit mask
     struct mask64(i64);
 }
 
 define_mask! {
-    #[doc = "128-bit mask"]
+    /// 128-bit mask
     struct mask128(i128);
 }
 
 define_mask! {
-    #[doc = "`isize`-wide mask"]
+    /// `isize`-wide mask
     struct masksize(isize);
 }
diff --git a/crates/core_simd/src/vectors_f32.rs b/crates/core_simd/src/vectors_f32.rs
index c2987a7f6314..9fcbd9d53f0f 100644
--- a/crates/core_simd/src/vectors_f32.rs
+++ b/crates/core_simd/src/vectors_f32.rs
@@ -1,20 +1,20 @@
 define_vector! {
-    #[doc = "Vector of two `f32` values"]
+    /// Vector of two `f32` values
     struct f32x2([f32; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `f32` values"]
+    /// Vector of four `f32` values
     struct f32x4([f32; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `f32` values"]
+    /// Vector of eight `f32` values
     struct f32x8([f32; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `f32` values"]
+    /// Vector of 16 `f32` values
     struct f32x16([f32; 16]);
 }
 
diff --git a/crates/core_simd/src/vectors_f64.rs b/crates/core_simd/src/vectors_f64.rs
index 4881df2b6dac..d741aabe88e0 100644
--- a/crates/core_simd/src/vectors_f64.rs
+++ b/crates/core_simd/src/vectors_f64.rs
@@ -1,15 +1,15 @@
 define_vector! {
-    #[doc = "Vector of two `f64` values"]
+    /// Vector of two `f64` values
     struct f64x2([f64; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `f64` values"]
+    /// Vector of four `f64` values
     struct f64x4([f64; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `f64` values"]
+    /// Vector of eight `f64` values
     struct f64x8([f64; 8]);
 }
 
diff --git a/crates/core_simd/src/vectors_i128.rs b/crates/core_simd/src/vectors_i128.rs
index 9eb0a12b8032..588f4cffb909 100644
--- a/crates/core_simd/src/vectors_i128.rs
+++ b/crates/core_simd/src/vectors_i128.rs
@@ -1,11 +1,11 @@
 define_vector! {
-    #[doc = "Vector of two `i128` values"]
+    /// Vector of two `i128` values
     #[derive(Eq, Ord, Hash)]
     struct i128x2([i128; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `i128` values"]
+    /// Vector of four `i128` values
     #[derive(Eq, Ord, Hash)]
     struct i128x4([i128; 4]);
 }
diff --git a/crates/core_simd/src/vectors_i16.rs b/crates/core_simd/src/vectors_i16.rs
index 682ee214eb50..52d9ef8379b0 100644
--- a/crates/core_simd/src/vectors_i16.rs
+++ b/crates/core_simd/src/vectors_i16.rs
@@ -1,29 +1,29 @@
 define_vector! {
-    #[doc = "Vector of two `i16` values"]
+    /// Vector of two `i16` values
     #[derive(Eq, Ord, Hash)]
     struct i16x2([i16; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `i16` values"]
+    /// Vector of four `i16` values
     #[derive(Eq, Ord, Hash)]
     struct i16x4([i16; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `i16` values"]
+    /// Vector of eight `i16` values
     #[derive(Eq, Ord, Hash)]
     struct i16x8([i16; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `i16` values"]
+    /// Vector of 16 `i16` values
     #[derive(Eq, Ord, Hash)]
     struct i16x16([i16; 16]);
 }
 
 define_vector! {
-    #[doc = "Vector of 32 `i16` values"]
+    /// Vector of 32 `i16` values
     #[derive(Eq, Ord, Hash)]
     struct i16x32([i16; 32]);
 }
diff --git a/crates/core_simd/src/vectors_i32.rs b/crates/core_simd/src/vectors_i32.rs
index d528fdbc2670..34ecc1694604 100644
--- a/crates/core_simd/src/vectors_i32.rs
+++ b/crates/core_simd/src/vectors_i32.rs
@@ -1,23 +1,23 @@
 define_vector! {
-    #[doc = "Vector of two `i32` values"]
+    /// Vector of two `i32` values
     #[derive(Eq, Ord, Hash)]
     struct i32x2([i32; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `i32` values"]
+    /// Vector of four `i32` values
     #[derive(Eq, Ord, Hash)]
     struct i32x4([i32; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `i32` values"]
+    /// Vector of eight `i32` values
     #[derive(Eq, Ord, Hash)]
     struct i32x8([i32; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `i32` values"]
+    /// Vector of 16 `i32` values
     #[derive(Eq, Ord, Hash)]
     struct i32x16([i32; 16]);
 }
diff --git a/crates/core_simd/src/vectors_i64.rs b/crates/core_simd/src/vectors_i64.rs
index 09dd27d94e34..58893c0dfedc 100644
--- a/crates/core_simd/src/vectors_i64.rs
+++ b/crates/core_simd/src/vectors_i64.rs
@@ -1,17 +1,17 @@
 define_vector! {
-    #[doc = "Vector of two `i64` values"]
+    /// Vector of two `i64` values
     #[derive(Eq, Ord, Hash)]
     struct i64x2([i64; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `i64` values"]
+    /// Vector of four `i64` values
     #[derive(Eq, Ord, Hash)]
     struct i64x4([i64; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `i64` values"]
+    /// Vector of eight `i64` values
     #[derive(Eq, Ord, Hash)]
     struct i64x8([i64; 8]);
 }
diff --git a/crates/core_simd/src/vectors_i8.rs b/crates/core_simd/src/vectors_i8.rs
index 8c9407c0c52c..c0551fc285e4 100644
--- a/crates/core_simd/src/vectors_i8.rs
+++ b/crates/core_simd/src/vectors_i8.rs
@@ -1,35 +1,35 @@
 define_vector! {
-    #[doc = "Vector of two `i8` values"]
+    /// Vector of two `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x2([i8; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `i8` values"]
+    /// Vector of four `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x4([i8; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `i8` values"]
+    /// Vector of eight `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x8([i8; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `i8` values"]
+    /// Vector of 16 `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x16([i8; 16]);
 }
 
 define_vector! {
-    #[doc = "Vector of 32 `i8` values"]
+    /// Vector of 32 `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x32([i8; 32]);
 }
 
 define_vector! {
-    #[doc = "Vector of 64 `i8` values"]
+    /// Vector of 64 `i8` values
     #[derive(Eq, Ord, Hash)]
     struct i8x64([i8; 64]);
 }
diff --git a/crates/core_simd/src/vectors_isize.rs b/crates/core_simd/src/vectors_isize.rs
index 4512d943d431..10a892bd0908 100644
--- a/crates/core_simd/src/vectors_isize.rs
+++ b/crates/core_simd/src/vectors_isize.rs
@@ -1,17 +1,17 @@
 define_vector! {
-    #[doc = "Vector of two `isize` values"]
+    /// Vector of two `isize` values
     #[derive(Eq, Ord, Hash)]
     struct isizex2([isize; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `isize` values"]
+    /// Vector of four `isize` values
     #[derive(Eq, Ord, Hash)]
     struct isizex4([isize; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `isize` values"]
+    /// Vector of eight `isize` values
     #[derive(Eq, Ord, Hash)]
     struct isizex8([isize; 8]);
 }
diff --git a/crates/core_simd/src/vectors_mask128.rs b/crates/core_simd/src/vectors_mask128.rs
index 3b1bacb7ad3c..adf56a3684b3 100644
--- a/crates/core_simd/src/vectors_mask128.rs
+++ b/crates/core_simd/src/vectors_mask128.rs
@@ -1,11 +1,11 @@
 use crate::mask128;
 
 define_mask_vector! {
-    #[doc = "vector of two `mask128` values"]
+    /// Vector of two `mask128` values
     struct mask128x2([i128 as mask128; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `mask128` values"]
+    /// Vector of four `mask128` values
     struct mask128x4([i128 as mask128; 4]);
 }
diff --git a/crates/core_simd/src/vectors_mask16.rs b/crates/core_simd/src/vectors_mask16.rs
index 8d076636caac..8cbae6b7bbd2 100644
--- a/crates/core_simd/src/vectors_mask16.rs
+++ b/crates/core_simd/src/vectors_mask16.rs
@@ -1,26 +1,26 @@
 use crate::mask16;
 
 define_mask_vector! {
-    #[doc = "vector of two `mask16` values"]
+    /// Vector of two `mask16` values
     struct mask16x2([i16 as mask16; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `mask16` values"]
+    /// Vector of four `mask16` values
     struct mask16x4([i16 as mask16; 4]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of eight `mask16` values"]
+    /// Vector of eight `mask16` values
     struct mask16x8([i16 as mask16; 8]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 16 `mask16` values"]
+    /// Vector of 16 `mask16` values
     struct mask16x16([i16 as mask16; 16]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 32 `mask16` values"]
+    /// Vector of 32 `mask16` values
     struct mask16x32([i16 as mask16; 32]);
 }
diff --git a/crates/core_simd/src/vectors_mask32.rs b/crates/core_simd/src/vectors_mask32.rs
index 64044bc4f578..fad191421f38 100644
--- a/crates/core_simd/src/vectors_mask32.rs
+++ b/crates/core_simd/src/vectors_mask32.rs
@@ -1,21 +1,21 @@
 use crate::mask32;
 
 define_mask_vector! {
-    #[doc = "vector of two `mask32` values"]
+    /// Vector of two `mask32` values
     struct mask32x2([i32 as mask32; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `mask32` values"]
+    /// Vector of four `mask32` values
     struct mask32x4([i32 as mask32; 4]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of eight `mask32` values"]
+    /// Vector of eight `mask32` values
     struct mask32x8([i32 as mask32; 8]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 16 `mask32` values"]
+    /// Vector of 16 `mask32` values
     struct mask32x16([i32 as mask32; 16]);
 }
diff --git a/crates/core_simd/src/vectors_mask64.rs b/crates/core_simd/src/vectors_mask64.rs
index b0c62b225c9b..554e731ccf24 100644
--- a/crates/core_simd/src/vectors_mask64.rs
+++ b/crates/core_simd/src/vectors_mask64.rs
@@ -1,16 +1,16 @@
 use crate::mask64;
 
 define_mask_vector! {
-    #[doc = "vector of two `mask64` values"]
+    /// Vector of two `mask64` values
     struct mask64x2([i64 as mask64; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `mask64` values"]
+    /// Vector of four `mask64` values
     struct mask64x4([i64 as mask64; 4]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of eight `mask64` values"]
+    /// Vector of eight `mask64` values
     struct mask64x8([i64 as mask64; 8]);
 }
diff --git a/crates/core_simd/src/vectors_mask8.rs b/crates/core_simd/src/vectors_mask8.rs
index c8f3cbac3c91..b6fbe5595189 100644
--- a/crates/core_simd/src/vectors_mask8.rs
+++ b/crates/core_simd/src/vectors_mask8.rs
@@ -1,31 +1,31 @@
 use crate::mask8;
 
 define_mask_vector! {
-    #[doc = "vector of two `mask8` values"]
+    /// Vector of two `mask8` values
     struct mask8x2([i8 as mask8; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `mask8` values"]
+    /// Vector of four `mask8` values
     struct mask8x4([i8 as mask8; 4]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of eight `mask8` values"]
+    /// Vector of eight `mask8` values
     struct mask8x8([i8 as mask8; 8]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 16 `mask8` values"]
+    /// Vector of 16 `mask8` values
     struct mask8x16([i8 as mask8; 16]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 32 `mask8` values"]
+    /// Vector of 32 `mask8` values
     struct mask8x32([i8 as mask8; 32]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of 64 `mask8` values"]
+    /// Vector of 64 `mask8` values
     struct mask8x64([i8 as mask8; 64]);
 }
diff --git a/crates/core_simd/src/vectors_masksize.rs b/crates/core_simd/src/vectors_masksize.rs
index 1bf911caffc6..a838aee51985 100644
--- a/crates/core_simd/src/vectors_masksize.rs
+++ b/crates/core_simd/src/vectors_masksize.rs
@@ -1,16 +1,16 @@
 use crate::masksize;
 
 define_mask_vector! {
-    #[doc = "vector of two `masksize` values"]
+    /// Vector of two `masksize` values
     struct masksizex2([isize as masksize; 2]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of four `masksize` values"]
+    /// Vector of four `masksize` values
     struct masksizex4([isize as masksize; 4]);
 }
 
 define_mask_vector! {
-    #[doc = "vector of eight `masksize` values"]
+    /// Vector of eight `masksize` values
     struct masksizex8([isize as masksize; 8]);
 }
diff --git a/crates/core_simd/src/vectors_u128.rs b/crates/core_simd/src/vectors_u128.rs
index 8d7418abe4c3..1412dfdc85dc 100644
--- a/crates/core_simd/src/vectors_u128.rs
+++ b/crates/core_simd/src/vectors_u128.rs
@@ -1,11 +1,11 @@
 define_vector! {
-    #[doc = "Vector of two `u128` values"]
+    /// Vector of two `u128` values
     #[derive(Eq, Ord, Hash)]
     struct u128x2([u128; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `u128` values"]
+    /// Vector of four `u128` values
     #[derive(Eq, Ord, Hash)]
     struct u128x4([u128; 4]);
 }
diff --git a/crates/core_simd/src/vectors_u16.rs b/crates/core_simd/src/vectors_u16.rs
index 6b4f3c553924..6fd7c64f4b31 100644
--- a/crates/core_simd/src/vectors_u16.rs
+++ b/crates/core_simd/src/vectors_u16.rs
@@ -1,29 +1,29 @@
 define_vector! {
-    #[doc = "Vector of two `u16` values"]
+    /// Vector of two `u16` values
     #[derive(Eq, Ord, Hash)]
     struct u16x2([u16; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `u16` values"]
+    /// Vector of four `u16` values
     #[derive(Eq, Ord, Hash)]
     struct u16x4([u16; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `u16` values"]
+    /// Vector of eight `u16` values
     #[derive(Eq, Ord, Hash)]
     struct u16x8([u16; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `u16` values"]
+    /// Vector of 16 `u16` values
     #[derive(Eq, Ord, Hash)]
     struct u16x16([u16; 16]);
 }
 
 define_vector! {
-    #[doc = "Vector of 32 `u16` values"]
+    /// Vector of 32 `u16` values
     #[derive(Eq, Ord, Hash)]
     struct u16x32([u16; 32]);
 }
diff --git a/crates/core_simd/src/vectors_u32.rs b/crates/core_simd/src/vectors_u32.rs
index 09aed52e6bb5..d4e1fd439ff3 100644
--- a/crates/core_simd/src/vectors_u32.rs
+++ b/crates/core_simd/src/vectors_u32.rs
@@ -1,23 +1,23 @@
 define_vector! {
-    #[doc = "Vector of two `u32` values"]
+    /// Vector of two `u32` values
     #[derive(Eq, Ord, Hash)]
     struct u32x2([u32; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `u32` values"]
+    /// Vector of four `u32` values
     #[derive(Eq, Ord, Hash)]
     struct u32x4([u32; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `u32` values"]
+    /// Vector of eight `u32` values
     #[derive(Eq, Ord, Hash)]
     struct u32x8([u32; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `u32` values"]
+    /// Vector of 16 `u32` values
     #[derive(Eq, Ord, Hash)]
     struct u32x16([u32; 16]);
 }
diff --git a/crates/core_simd/src/vectors_u64.rs b/crates/core_simd/src/vectors_u64.rs
index b19739e6657d..6a2b0ef76309 100644
--- a/crates/core_simd/src/vectors_u64.rs
+++ b/crates/core_simd/src/vectors_u64.rs
@@ -1,17 +1,17 @@
 define_vector! {
-    #[doc = "Vector of two `u64` values"]
+    /// Vector of two `u64` values
     #[derive(Eq, Ord, Hash)]
     struct u64x2([u64; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `u64` values"]
+    /// Vector of four `u64` values
     #[derive(Eq, Ord, Hash)]
     struct u64x4([u64; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `u64` values"]
+    /// Vector of eight `u64` values
     #[derive(Eq, Ord, Hash)]
     struct u64x8([u64; 8]);
 }
diff --git a/crates/core_simd/src/vectors_u8.rs b/crates/core_simd/src/vectors_u8.rs
index 1c31578d0a7e..487a25e2d66e 100644
--- a/crates/core_simd/src/vectors_u8.rs
+++ b/crates/core_simd/src/vectors_u8.rs
@@ -1,35 +1,35 @@
 define_vector! {
-    #[doc = "Vector of two `u8` values"]
+    /// Vector of two `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x2([u8; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `u8` values"]
+    /// Vector of four `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x4([u8; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `u8` values"]
+    /// Vector of eight `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x8([u8; 8]);
 }
 
 define_vector! {
-    #[doc = "Vector of 16 `u8` values"]
+    /// Vector of 16 `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x16([u8; 16]);
 }
 
 define_vector! {
-    #[doc = "Vector of 32 `u8` values"]
+    /// Vector of 32 `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x32([u8; 32]);
 }
 
 define_vector! {
-    #[doc = "Vector of 64 `u8` values"]
+    /// Vector of 64 `u8` values
     #[derive(Eq, Ord, Hash)]
     struct u8x64([u8; 64]);
 }
diff --git a/crates/core_simd/src/vectors_usize.rs b/crates/core_simd/src/vectors_usize.rs
index 30c4da8438b4..2318d63a0014 100644
--- a/crates/core_simd/src/vectors_usize.rs
+++ b/crates/core_simd/src/vectors_usize.rs
@@ -1,17 +1,17 @@
 define_vector! {
-    #[doc = "Vector of two `usize` values"]
+    /// Vector of two `usize` values
     #[derive(Eq, Ord, Hash)]
     struct usizex2([usize; 2]);
 }
 
 define_vector! {
-    #[doc = "Vector of four `usize` values"]
+    /// Vector of four `usize` values
     #[derive(Eq, Ord, Hash)]
     struct usizex4([usize; 4]);
 }
 
 define_vector! {
-    #[doc = "Vector of eight `usize` values"]
+    /// Vector of eight `usize` values
     #[derive(Eq, Ord, Hash)]
     struct usizex8([usize; 8]);
 }