Rollup merge of rust-lang#136923 - samueltardieu:push-vxxqvqwspssv, r=davidtwco

matthiaskrgr · web-flow · commit 7b3d14c2dac9 · 2025-02-19T21:16:11.000+01:00
Lint `#[must_use]` attributes applied to methods in trait impls

The `#[must_use]` attribute has no effect when applied to methods in trait implementations. This PR adds it to the unused `#[must_use]` lint, and cleans the extra attributes in portable-simd and Clippy.
diff --git a/portable-simd/crates/core_simd/src/masks.rs b/portable-simd/crates/core_simd/src/masks.rs
@@ -401,7 +401,6 @@ where
     LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
-    #[must_use = "method returns a defaulted mask with all elements set to false (0)"]
     fn default() -> Self {
         Self::splat(false)
     }
@@ -413,7 +412,6 @@ where
     LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
-    #[must_use = "method returns a new bool and does not mutate the original value"]
     fn eq(&self, other: &Self) -> bool {
         self.0 == other.0
     }
@@ -425,7 +423,6 @@ where
     LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
-    #[must_use = "method returns a new Ordering and does not mutate the original value"]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.0.partial_cmp(&other.0)
     }
@@ -451,7 +448,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitand(self, rhs: Self) -> Self {
         Self(self.0 & rhs.0)
     }
@@ -464,7 +460,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitand(self, rhs: bool) -> Self {
         self & Self::splat(rhs)
     }
@@ -477,7 +472,6 @@ where
 {
     type Output = Mask<T, N>;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitand(self, rhs: Mask<T, N>) -> Mask<T, N> {
         Mask::splat(self) & rhs
     }
@@ -490,7 +484,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitor(self, rhs: Self) -> Self {
         Self(self.0 | rhs.0)
     }
@@ -503,7 +496,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitor(self, rhs: bool) -> Self {
         self | Self::splat(rhs)
     }
@@ -516,7 +508,6 @@ where
 {
     type Output = Mask<T, N>;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitor(self, rhs: Mask<T, N>) -> Mask<T, N> {
         Mask::splat(self) | rhs
     }
@@ -529,7 +520,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitxor(self, rhs: Self) -> Self::Output {
         Self(self.0 ^ rhs.0)
     }
@@ -542,7 +532,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitxor(self, rhs: bool) -> Self::Output {
         self ^ Self::splat(rhs)
     }
@@ -555,7 +544,6 @@ where
 {
     type Output = Mask<T, N>;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitxor(self, rhs: Mask<T, N>) -> Self::Output {
         Mask::splat(self) ^ rhs
     }
@@ -568,7 +556,6 @@ where
 {
     type Output = Mask<T, N>;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn not(self) -> Self::Output {
         Self(!self.0)
     }
diff --git a/portable-simd/crates/core_simd/src/masks/full_masks.rs b/portable-simd/crates/core_simd/src/masks/full_masks.rs
@@ -21,7 +21,6 @@ where
     LaneCount<N>: SupportedLaneCount,
 {
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn clone(&self) -> Self {
         *self
     }
@@ -252,7 +251,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitand(self, rhs: Self) -> Self {
         // Safety: `self` is an integer vector
         unsafe { Self(core::intrinsics::simd::simd_and(self.0, rhs.0)) }
@@ -266,7 +264,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitor(self, rhs: Self) -> Self {
         // Safety: `self` is an integer vector
         unsafe { Self(core::intrinsics::simd::simd_or(self.0, rhs.0)) }
@@ -280,7 +277,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn bitxor(self, rhs: Self) -> Self {
         // Safety: `self` is an integer vector
         unsafe { Self(core::intrinsics::simd::simd_xor(self.0, rhs.0)) }
@@ -294,7 +290,6 @@ where
 {
     type Output = Self;
     #[inline]
-    #[must_use = "method returns a new mask and does not mutate the original value"]
     fn not(self) -> Self::Output {
         Self::splat(true) ^ self
     }
diff --git a/portable-simd/crates/core_simd/src/ops.rs b/portable-simd/crates/core_simd/src/ops.rs
@@ -135,7 +135,6 @@ macro_rules! for_base_types {
                     type Output = $out;
 
                     #[inline]
-                    #[must_use = "operator returns a new vector without mutating the inputs"]
                     // TODO: only useful for int Div::div, but we hope that this
                     // will essentially always get inlined anyway.
                     #[track_caller]
diff --git a/portable-simd/crates/core_simd/src/ops/deref.rs b/portable-simd/crates/core_simd/src/ops/deref.rs
@@ -18,7 +18,6 @@ macro_rules! deref_lhs {
             type Output = Simd<T, N>;
 
             #[inline]
-            #[must_use = "operator returns a new vector without mutating the inputs"]
             fn $call(self, rhs: $simd) -> Self::Output {
                 (*self).$call(rhs)
             }
@@ -39,7 +38,6 @@ macro_rules! deref_rhs {
             type Output = Simd<T, N>;
 
             #[inline]
-            #[must_use = "operator returns a new vector without mutating the inputs"]
             fn $call(self, rhs: &$simd) -> Self::Output {
                 self.$call(*rhs)
             }
@@ -71,7 +69,6 @@ macro_rules! deref_ops {
                 type Output = $simd;
 
                 #[inline]
-                #[must_use = "operator returns a new vector without mutating the inputs"]
                 fn $call(self, rhs: &'rhs $simd) -> Self::Output {
                     (*self).$call(*rhs)
                 }
diff --git a/portable-simd/crates/core_simd/src/ops/unary.rs b/portable-simd/crates/core_simd/src/ops/unary.rs
@@ -11,7 +11,6 @@ macro_rules! neg {
             type Output = Self;
 
             #[inline]
-            #[must_use = "operator returns a new vector without mutating the input"]
             fn neg(self) -> Self::Output {
                 // Safety: `self` is a signed vector
                 unsafe { core::intrinsics::simd::simd_neg(self) }
@@ -46,7 +45,6 @@ macro_rules! not {
             type Output = Self;
 
             #[inline]
-            #[must_use = "operator returns a new vector without mutating the input"]
             fn not(self) -> Self::Output {
                 self ^ (Simd::splat(!(0 as $scalar)))
             }
diff --git a/portable-simd/crates/core_simd/src/simd/num/float.rs b/portable-simd/crates/core_simd/src/simd/num/float.rs
@@ -371,7 +371,6 @@ macro_rules! impl_trait {
             }
 
             #[inline]
-            #[must_use = "method returns a new mask and does not mutate the original value"]
             fn is_normal(self) -> Self::Mask {
                 !(self.abs().simd_eq(Self::splat(0.0)) | self.is_nan() | self.is_subnormal() | self.is_infinite())
             }

Original file line number	Diff line number	Diff line change
`@@ -401,7 +401,6 @@ where`
`401`	`401`	`LaneCount<N>: SupportedLaneCount,`
`402`	`402`	`{`
`403`	`403`	`#[inline]`
`404`		`- #[must_use = "method returns a defaulted mask with all elements set to false (0)"]`
`405`	`404`	`fn default() -> Self {`
`406`	`405`	`Self::splat(false)`
`407`	`406`	`}`
`@@ -413,7 +412,6 @@ where`
`413`	`412`	`LaneCount<N>: SupportedLaneCount,`
`414`	`413`	`{`
`415`	`414`	`#[inline]`
`416`		`- #[must_use = "method returns a new bool and does not mutate the original value"]`
`417`	`415`	`fn eq(&self, other: &Self) -> bool {`
`418`	`416`	`self.0 == other.0`
`419`	`417`	`}`
`@@ -425,7 +423,6 @@ where`
`425`	`423`	`LaneCount<N>: SupportedLaneCount,`
`426`	`424`	`{`
`427`	`425`	`#[inline]`
`428`		`- #[must_use = "method returns a new Ordering and does not mutate the original value"]`
`429`	`426`	`fn partial_cmp(&self, other: &Self) -> Option<Ordering> {`
`430`	`427`	`self.0.partial_cmp(&other.0)`
`431`	`428`	`}`
`@@ -451,7 +448,6 @@ where`
`451`	`448`	`{`
`452`	`449`	`type Output = Self;`
`453`	`450`	`#[inline]`
`454`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`455`	`451`	`fn bitand(self, rhs: Self) -> Self {`
`456`	`452`	`Self(self.0 & rhs.0)`
`457`	`453`	`}`
`@@ -464,7 +460,6 @@ where`
`464`	`460`	`{`
`465`	`461`	`type Output = Self;`
`466`	`462`	`#[inline]`
`467`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`468`	`463`	`fn bitand(self, rhs: bool) -> Self {`
`469`	`464`	`self & Self::splat(rhs)`
`470`	`465`	`}`
`@@ -477,7 +472,6 @@ where`
`477`	`472`	`{`
`478`	`473`	`type Output = Mask<T, N>;`
`479`	`474`	`#[inline]`
`480`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`481`	`475`	`fn bitand(self, rhs: Mask<T, N>) -> Mask<T, N> {`
`482`	`476`	`Mask::splat(self) & rhs`
`483`	`477`	`}`
`@@ -490,7 +484,6 @@ where`
`490`	`484`	`{`
`491`	`485`	`type Output = Self;`
`492`	`486`	`#[inline]`
`493`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`494`	`487`	`fn bitor(self, rhs: Self) -> Self {`
`495`	`488`	`Self(self.0 \| rhs.0)`
`496`	`489`	`}`
`@@ -503,7 +496,6 @@ where`
`503`	`496`	`{`
`504`	`497`	`type Output = Self;`
`505`	`498`	`#[inline]`
`506`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`507`	`499`	`fn bitor(self, rhs: bool) -> Self {`
`508`	`500`	`self \| Self::splat(rhs)`
`509`	`501`	`}`
`@@ -516,7 +508,6 @@ where`
`516`	`508`	`{`
`517`	`509`	`type Output = Mask<T, N>;`
`518`	`510`	`#[inline]`
`519`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`520`	`511`	`fn bitor(self, rhs: Mask<T, N>) -> Mask<T, N> {`
`521`	`512`	`Mask::splat(self) \| rhs`
`522`	`513`	`}`
`@@ -529,7 +520,6 @@ where`
`529`	`520`	`{`
`530`	`521`	`type Output = Self;`
`531`	`522`	`#[inline]`
`532`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`533`	`523`	`fn bitxor(self, rhs: Self) -> Self::Output {`
`534`	`524`	`Self(self.0 ^ rhs.0)`
`535`	`525`	`}`
`@@ -542,7 +532,6 @@ where`
`542`	`532`	`{`
`543`	`533`	`type Output = Self;`
`544`	`534`	`#[inline]`
`545`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`546`	`535`	`fn bitxor(self, rhs: bool) -> Self::Output {`
`547`	`536`	`self ^ Self::splat(rhs)`
`548`	`537`	`}`
`@@ -555,7 +544,6 @@ where`
`555`	`544`	`{`
`556`	`545`	`type Output = Mask<T, N>;`
`557`	`546`	`#[inline]`
`558`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`559`	`547`	`fn bitxor(self, rhs: Mask<T, N>) -> Self::Output {`
`560`	`548`	`Mask::splat(self) ^ rhs`
`561`	`549`	`}`
`@@ -568,7 +556,6 @@ where`
`568`	`556`	`{`
`569`	`557`	`type Output = Mask<T, N>;`
`570`	`558`	`#[inline]`
`571`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`572`	`559`	`fn not(self) -> Self::Output {`
`573`	`560`	`Self(!self.0)`
`574`	`561`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ where`
`21`	`21`	`LaneCount<N>: SupportedLaneCount,`
`22`	`22`	`{`
`23`	`23`	`#[inline]`
`24`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`25`	`24`	`fn clone(&self) -> Self {`
`26`	`25`	`*self`
`27`	`26`	`}`
`@@ -252,7 +251,6 @@ where`
`252`	`251`	`{`
`253`	`252`	`type Output = Self;`
`254`	`253`	`#[inline]`
`255`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`256`	`254`	`fn bitand(self, rhs: Self) -> Self {`
`257`	`255`	// Safety: `self` is an integer vector
`258`	`256`	`unsafe { Self(core::intrinsics::simd::simd_and(self.0, rhs.0)) }`
`@@ -266,7 +264,6 @@ where`
`266`	`264`	`{`
`267`	`265`	`type Output = Self;`
`268`	`266`	`#[inline]`
`269`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`270`	`267`	`fn bitor(self, rhs: Self) -> Self {`
`271`	`268`	// Safety: `self` is an integer vector
`272`	`269`	`unsafe { Self(core::intrinsics::simd::simd_or(self.0, rhs.0)) }`
`@@ -280,7 +277,6 @@ where`
`280`	`277`	`{`
`281`	`278`	`type Output = Self;`
`282`	`279`	`#[inline]`
`283`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`284`	`280`	`fn bitxor(self, rhs: Self) -> Self {`
`285`	`281`	// Safety: `self` is an integer vector
`286`	`282`	`unsafe { Self(core::intrinsics::simd::simd_xor(self.0, rhs.0)) }`
`@@ -294,7 +290,6 @@ where`
`294`	`290`	`{`
`295`	`291`	`type Output = Self;`
`296`	`292`	`#[inline]`
`297`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`298`	`293`	`fn not(self) -> Self::Output {`
`299`	`294`	`Self::splat(true) ^ self`
`300`	`295`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ macro_rules! deref_lhs {`
`18`	`18`	`type Output = Simd<T, N>;`
`19`	`19`
`20`	`20`	`#[inline]`
`21`		`- #[must_use = "operator returns a new vector without mutating the inputs"]`
`22`	`21`	`fn $call(self, rhs: $simd) -> Self::Output {`
`23`	`22`	`(*self).$call(rhs)`
`24`	`23`	`}`
`@@ -39,7 +38,6 @@ macro_rules! deref_rhs {`
`39`	`38`	`type Output = Simd<T, N>;`
`40`	`39`
`41`	`40`	`#[inline]`
`42`		`- #[must_use = "operator returns a new vector without mutating the inputs"]`
`43`	`41`	`fn $call(self, rhs: &$simd) -> Self::Output {`
`44`	`42`	`self.$call(*rhs)`
`45`	`43`	`}`
`@@ -71,7 +69,6 @@ macro_rules! deref_ops {`
`71`	`69`	`type Output = $simd;`
`72`	`70`
`73`	`71`	`#[inline]`
`74`		`- #[must_use = "operator returns a new vector without mutating the inputs"]`
`75`	`72`	`fn $call(self, rhs: &'rhs $simd) -> Self::Output {`
`76`	`73`	`(self).$call(rhs)`
`77`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -371,7 +371,6 @@ macro_rules! impl_trait {`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`#[inline]`
`374`		`- #[must_use = "method returns a new mask and does not mutate the original value"]`
`375`	`374`	`fn is_normal(self) -> Self::Mask {`
`376`	`375`	`!(self.abs().simd_eq(Self::splat(0.0)) \| self.is_nan() \| self.is_subnormal() \| self.is_infinite())`
`377`	`376`	`}`