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

matthiaskrgr · web-flow · commit c29cc600fdc7 · 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/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -1431,37 +1431,48 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
     /// Warns against some misuses of `#[must_use]`
     fn check_must_use(&self, hir_id: HirId, attr: &Attribute, target: Target) {
-        if !matches!(
+        if matches!(
             target,
             Target::Fn
                 | Target::Enum
                 | Target::Struct
                 | Target::Union
-                | Target::Method(_)
+                | Target::Method(MethodKind::Trait { body: false } | MethodKind::Inherent)
                 | Target::ForeignFn
                 // `impl Trait` in return position can trip
                 // `unused_must_use` if `Trait` is marked as
                 // `#[must_use]`
                 | Target::Trait
         ) {
-            let article = match target {
-                Target::ExternCrate
-                | Target::Enum
-                | Target::Impl
-                | Target::Expression
-                | Target::Arm
-                | Target::AssocConst
-                | Target::AssocTy => "an",
-                _ => "a",
-            };
+            return;
+        }
 
-            self.tcx.emit_node_span_lint(
-                UNUSED_ATTRIBUTES,
-                hir_id,
-                attr.span,
-                errors::MustUseNoEffect { article, target },
-            );
+        // `#[must_use]` can be applied to a trait method definition with a default body
+        if let Target::Method(MethodKind::Trait { body: true }) = target
+            && let parent_def_id = self.tcx.hir().get_parent_item(hir_id).def_id
+            && let containing_item = self.tcx.hir().expect_item(parent_def_id)
+            && let hir::ItemKind::Trait(..) = containing_item.kind
+        {
+            return;
         }
+
+        let article = match target {
+            Target::ExternCrate
+            | Target::Enum
+            | Target::Impl
+            | Target::Expression
+            | Target::Arm
+            | Target::AssocConst
+            | Target::AssocTy => "an",
+            _ => "a",
+        };
+
+        self.tcx.emit_node_span_lint(
+            UNUSED_ATTRIBUTES,
+            hir_id,
+            attr.span,
+            errors::MustUseNoEffect { article, target },
+        );
     }
 
     /// Checks if `#[must_not_suspend]` is applied to a struct, enum, union, or trait.
diff --git a/library/portable-simd/crates/core_simd/src/masks.rs b/library/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/library/portable-simd/crates/core_simd/src/masks/full_masks.rs b/library/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/library/portable-simd/crates/core_simd/src/ops.rs b/library/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/library/portable-simd/crates/core_simd/src/ops/deref.rs b/library/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/library/portable-simd/crates/core_simd/src/ops/unary.rs b/library/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/library/portable-simd/crates/core_simd/src/simd/num/float.rs b/library/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())
             }
diff --git a/src/tools/clippy/clippy_lints/src/infinite_iter.rs b/src/tools/clippy/clippy_lints/src/infinite_iter.rs
@@ -94,7 +94,6 @@ impl Finiteness {
 }
 
 impl From<bool> for Finiteness {
-    #[must_use]
     fn from(b: bool) -> Self {
         if b { Infinite } else { Finite }
     }
diff --git a/src/tools/clippy/clippy_utils/src/consts.rs b/src/tools/clippy/clippy_utils/src/consts.rs
@@ -351,21 +351,18 @@ pub enum FullInt {
 }
 
 impl PartialEq for FullInt {
-    #[must_use]
     fn eq(&self, other: &Self) -> bool {
         self.cmp(other) == Ordering::Equal
     }
 }
 
 impl PartialOrd for FullInt {
-    #[must_use]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
 impl Ord for FullInt {
-    #[must_use]
     fn cmp(&self, other: &Self) -> Ordering {
         use FullInt::{S, U};
 
diff --git a/tests/ui/lint/unused/unused_attributes-must_use.rs b/tests/ui/lint/unused/unused_attributes-must_use.rs
@@ -79,6 +79,11 @@ trait Use {
 #[must_use] //~ ERROR `#[must_use]` has no effect
 impl Use for () {
     type AssocTy = ();
+
+    #[must_use] //~ ERROR `#[must_use]` has no effect
+    fn get_four(&self) -> usize {
+        4
+    }
 }
 
 #[must_use] //~ ERROR `#[must_use]` has no effect
diff --git a/tests/ui/lint/unused/unused_attributes-must_use.stderr b/tests/ui/lint/unused/unused_attributes-must_use.stderr

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`	`}`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,6 @@ impl Finiteness {`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`impl From<bool> for Finiteness {`
`97`		`- #[must_use]`
`98`	`97`	`fn from(b: bool) -> Self {`
`99`	`98`	`if b { Infinite } else { Finite }`
`100`	`99`	`}`
Original file line number	Diff line number	Diff line change
`@@ -351,21 +351,18 @@ pub enum FullInt {`
`351`	`351`	`}`
`352`	`352`
`353`	`353`	`impl PartialEq for FullInt {`
`354`		`- #[must_use]`
`355`	`354`	`fn eq(&self, other: &Self) -> bool {`
`356`	`355`	`self.cmp(other) == Ordering::Equal`
`357`	`356`	`}`
`358`	`357`	`}`
`359`	`358`
`360`	`359`	`impl PartialOrd for FullInt {`
`361`		`- #[must_use]`
`362`	`360`	`fn partial_cmp(&self, other: &Self) -> Option<Ordering> {`
`363`	`361`	`Some(self.cmp(other))`
`364`	`362`	`}`
`365`	`363`	`}`
`366`	`364`
`367`	`365`	`impl Ord for FullInt {`
`368`		`- #[must_use]`
`369`	`366`	`fn cmp(&self, other: &Self) -> Ordering {`
`370`	`367`	`use FullInt::{S, U};`
`371`	`368`