add suggestions to rest_when_destructuring_struct

Erk- · Erk- · commit d924014f380f · 2025-06-08T11:39:22.000+02:00
diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -952,6 +952,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));
     store.register_late_pass(|_| Box::new(infallible_try_from::InfallibleTryFrom));
     store.register_late_pass(|_| Box::new(coerce_container_to_any::CoerceContainerToAny));
-    store.register_early_pass(|| Box::new(rest_when_destructuring_struct::RestWhenDestructuringStruct));
+    store.register_late_pass(|_| Box::new(rest_when_destructuring_struct::RestWhenDestructuringStruct));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/clippy_lints/src/rest_when_destructuring_struct.rs b/clippy_lints/src/rest_when_destructuring_struct.rs
@@ -1,6 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_help;
-use rustc_ast::ast::{Pat, PatFieldsRest, PatKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
+use crate::rustc_lint::LintContext as _;
+use clippy_utils::diagnostics::span_lint_and_then;
+use itertools::Itertools;
+use rustc_lint::LateLintPass;
+use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
 
 declare_clippy_lint! {
@@ -41,17 +43,57 @@ declare_clippy_lint! {
 }
 declare_lint_pass!(RestWhenDestructuringStruct => [REST_WHEN_DESTRUCTURING_STRUCT]);
 
-impl EarlyLintPass for RestWhenDestructuringStruct {
-    fn check_pat(&mut self, cx: &EarlyContext<'_>, pat: &Pat) {
-        if let PatKind::Struct(_, _, _, PatFieldsRest::Rest) = pat.kind {
-            span_lint_and_help(
-                cx,
-                REST_WHEN_DESTRUCTURING_STRUCT,
-                pat.span,
-                "struct destructuring with rest (..)",
-                None,
-                "consider explicitly ignoring remaining fields with wildcard patterns (x: _)",
-            );
+impl<'tcx> LateLintPass<'tcx> for RestWhenDestructuringStruct {
+    fn check_pat(&mut self, cx: &rustc_lint::LateContext<'tcx>, pat: &'tcx rustc_hir::Pat<'tcx>) {
+        if pat.span.in_external_macro(cx.tcx.sess.source_map()) {
+            return;
+        }
+
+        if let rustc_hir::PatKind::Struct(path, fields, true) = pat.kind {
+            let qty = cx.typeck_results().qpath_res(&path, pat.hir_id);
+            let ty = cx.typeck_results().pat_ty(pat);
+            if let ty::Adt(a, _) = ty.kind() {
+                let vid = a.variant_index_with_id(qty.def_id());
+                let mut rest_fields = a.variants()[vid]
+                    .fields
+                    .iter()
+                    .map(|field| field.ident(cx.tcx))
+                    .filter(|pf| !fields.iter().any(|x| x.ident == *pf))
+                    .map(|x| format!("{x}: _"));
+                let fmt_fields = rest_fields.join(", ");
+
+                let sm = cx.sess().source_map();
+
+                // It is not possible to get the span of the et cetera symbol at HIR level
+                // so we have to get it in a bit of a roundabout way:
+
+                // Find the end of the last field if any.
+                let last_field = fields.iter().last().map(|x| x.span.shrink_to_hi());
+                // If no last field take the whole pattern.
+                let last_field = last_field.unwrap_or(pat.span.shrink_to_lo());
+                // Create a new span starting and ending just before the first .
+                let before_dot = sm.span_extend_to_next_char(last_field, '.', true).shrink_to_hi();
+                // Extend the span to the end of the line
+                let rest_of_line = sm.span_extend_to_next_char(before_dot, '\n', true);
+                // Shrink the span so it only contains dots
+                let dotdot = sm.span_take_while(rest_of_line, |x| *x == '.');
+
+                span_lint_and_then(
+                    cx,
+                    REST_WHEN_DESTRUCTURING_STRUCT,
+                    pat.span,
+                    "struct destructuring with rest (..)",
+                    |diag| {
+                        // println!("{:?}", pat);
+                        diag.span_suggestion_verbose(
+                            dotdot,
+                            "consider explicitly ignoring remaining fields with wildcard patterns (x: _)",
+                            fmt_fields,
+                            rustc_errors::Applicability::MachineApplicable,
+                        );
+                    },
+                );
+            }
         }
     }
 }
diff --git a/tests/ui/rest_when_destructuring_struct.fixed b/tests/ui/rest_when_destructuring_struct.fixed
@@ -0,0 +1,39 @@
+#![warn(clippy::rest_when_destructuring_struct)]
+#![allow(dead_code)]
+#![allow(unused_variables)]
+
+struct S {
+    a: u8,
+    b: u8,
+    c: u8,
+}
+
+enum E {
+    A { a1: u8, a2: u8 },
+    B { b1: u8, b2: u8 },
+    C {},
+}
+
+fn main() {
+    let s = S { a: 1, b: 2, c: 3 };
+
+    let S { a, b, c: _ } = s;
+    //~^ rest_when_destructuring_struct
+
+    let e = E::A { a1: 1, a2: 2 };
+
+    match e {
+        E::A { a1, a2 } => (),
+        E::B { b1: _, b2: _ } => (),
+        //~^ rest_when_destructuring_struct
+        E::C {  } => (),
+        //~^ rest_when_destructuring_struct
+    }
+
+    match e {
+        E::A { a1: _, a2: _ } => (),
+        E::B { b1: _, b2: _ } => (),
+        //~^ rest_when_destructuring_struct
+        E::C {} => (),
+    }
+}
diff --git a/tests/ui/rest_when_destructuring_struct.rs b/tests/ui/rest_when_destructuring_struct.rs
@@ -11,6 +11,7 @@ struct S {
 enum E {
     A { a1: u8, a2: u8 },
     B { b1: u8, b2: u8 },
+    C {},
 }
 
 fn main() {
@@ -25,10 +26,14 @@ fn main() {
         E::A { a1, a2 } => (),
         E::B { .. } => (),
         //~^ rest_when_destructuring_struct
+        E::C { .. } => (),
+        //~^ rest_when_destructuring_struct
     }
 
     match e {
         E::A { a1: _, a2: _ } => (),
-        E::B { b1, b2: _ } => (),
+        E::B { b1: _, .. } => (),
+        //~^ rest_when_destructuring_struct
+        E::C {} => (),
     }
 }
diff --git a/tests/ui/rest_when_destructuring_struct.stderr b/tests/ui/rest_when_destructuring_struct.stderr
@@ -1,20 +1,52 @@
 error: struct destructuring with rest (..)
-  --> tests/ui/rest_when_destructuring_struct.rs:19:9
+  --> tests/ui/rest_when_destructuring_struct.rs:20:9
    |
 LL |     let S { a, b, .. } = s;
    |         ^^^^^^^^^^^^^^
    |
-   = help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
    = note: `-D clippy::rest-when-destructuring-struct` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::rest_when_destructuring_struct)]`
+help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+   |
+LL -     let S { a, b, .. } = s;
+LL +     let S { a, b, c: _ } = s;
+   |
 
 error: struct destructuring with rest (..)
-  --> tests/ui/rest_when_destructuring_struct.rs:26:9
+  --> tests/ui/rest_when_destructuring_struct.rs:27:9
    |
 LL |         E::B { .. } => (),
    |         ^^^^^^^^^^^
    |
-   = help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+   |
+LL -         E::B { .. } => (),
+LL +         E::B { b1: _, b2: _ } => (),
+   |
+
+error: struct destructuring with rest (..)
+  --> tests/ui/rest_when_destructuring_struct.rs:29:9
+   |
+LL |         E::C { .. } => (),
+   |         ^^^^^^^^^^^
+   |
+help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+   |
+LL -         E::C { .. } => (),
+LL +         E::C {  } => (),
+   |
+
+error: struct destructuring with rest (..)
+  --> tests/ui/rest_when_destructuring_struct.rs:35:9
+   |
+LL |         E::B { b1: _, .. } => (),
+   |         ^^^^^^^^^^^^^^^^^^
+   |
+help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+   |
+LL -         E::B { b1: _, .. } => (),
+LL +         E::B { b1: _, b2: _ } => (),
+   |
 
-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors
 

Original file line number	Diff line number	Diff line change
`@@ -952,6 +952,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {`
`952`	`952`	`store.register_late_pass(\|_\| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));`
`953`	`953`	`store.register_late_pass(\|_\| Box::new(infallible_try_from::InfallibleTryFrom));`
`954`	`954`	`store.register_late_pass(\|_\| Box::new(coerce_container_to_any::CoerceContainerToAny));`
`955`		`- store.register_early_pass(\|\| Box::new(rest_when_destructuring_struct::RestWhenDestructuringStruct));`
	`955`	`+ store.register_late_pass(\|_\| Box::new(rest_when_destructuring_struct::RestWhenDestructuringStruct));`
`956`	`956`	// add lints here, do not remove this comment, it's used in `new_lint`
`957`	`957`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ struct S {`
`11`	`11`	`enum E {`
`12`	`12`	`A { a1: u8, a2: u8 },`
`13`	`13`	`B { b1: u8, b2: u8 },`
	`14`	`+ C {},`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`fn main() {`
`@@ -25,10 +26,14 @@ fn main() {`
`25`	`26`	`E::A { a1, a2 } => (),`
`26`	`27`	`E::B { .. } => (),`
`27`	`28`	`//~^ rest_when_destructuring_struct`
	`29`	`+ E::C { .. } => (),`
	`30`	`+ //~^ rest_when_destructuring_struct`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`match e {`
`31`	`34`	`E::A { a1: _, a2: _ } => (),`
`32`		`- E::B { b1, b2: _ } => (),`
	`35`	`+ E::B { b1: _, .. } => (),`
	`36`	`+ //~^ rest_when_destructuring_struct`
	`37`	`+ E::C {} => (),`
`33`	`38`	`}`
`34`	`39`	`}`