add new lint: rest_when_destructuring_struct

Author: Erk-

CHANGELOG.md

@@ -6238,6 +6238,7 @@ Released 2018-09-13
 [`repr_packed_without_abi`]: https://rust-lang.github.io/rust-clippy/master/index.html#repr_packed_without_abi
 [`reserve_after_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#reserve_after_initialization
 [`rest_pat_in_fully_bound_structs`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_pat_in_fully_bound_structs
+[`rest_when_destructuring_struct`]: https://rust-lang.github.io/rust-clippy/master/index.html#rest_when_destructuring_struct
 [`result_expect_used`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_expect_used
 [`result_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_filter_map
 [`result_large_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#result_large_err

clippy_lints/src/declared_lints.rs

@@ -655,6 +655,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::regex::TRIVIAL_REGEX_INFO,
     crate::repeat_vec_with_capacity::REPEAT_VEC_WITH_CAPACITY_INFO,
     crate::reserve_after_initialization::RESERVE_AFTER_INITIALIZATION_INFO,
+    crate::rest_when_destructuring_struct::REST_WHEN_DESTRUCTURING_STRUCT_INFO,
     crate::return_self_not_must_use::RETURN_SELF_NOT_MUST_USE_INFO,
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,

clippy_lints/src/lib.rs

@@ -329,6 +329,7 @@ mod reference;
 mod regex;
 mod repeat_vec_with_capacity;
 mod reserve_after_initialization;
+mod rest_when_destructuring_struct;
 mod return_self_not_must_use;
 mod returns;
 mod same_name_method;
@@ -951,5 +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));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

clippy_lints/src/rest_when_destructuring_struct.rs

@@ -0,0 +1,58 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use rustc_ast::ast::{Pat, PatFieldsRest, PatKind};
+use rustc_lint::{EarlyContext, EarlyLintPass};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Disallows the use of rest patterns when destructuring structs.
+    ///
+    /// ### Why is this bad?
+    /// It might lead to unhandled fields when the struct changes.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// struct S {
+    ///     a: u8,
+    ///     b: u8,
+    ///     c: u8,
+    /// }
+    ///
+    /// let s = S { a: 1, b: 2, c: 3 };
+    ///
+    /// let S { a, b, .. } = s;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// struct S {
+    ///     a: u8,
+    ///     b: u8,
+    ///     c: u8,
+    /// }
+    ///
+    /// let s = S { a: 1, b: 2, c: 3 };
+    ///
+    /// let S { a, b, c: _ } = s;
+    /// ```
+    #[clippy::version = "1.89.0"]
+    pub REST_WHEN_DESTRUCTURING_STRUCT,
+    nursery,
+    "rest (..) in destructuring expression"
+}
+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 {
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            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: _)",
+            );
+        }
+    }
+}

tests/ui/rest_when_destructuring_struct.rs

@@ -0,0 +1,34 @@
+#![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 },
+}
+
+fn main() {
+    let s = S { a: 1, b: 2, c: 3 };
+
+    let S { a, b, .. } = s;
+    //~^ rest_when_destructuring_struct
+
+    let e = E::A { a1: 1, a2: 2 };
+
+    match e {
+        E::A { a1, a2 } => (),
+        E::B { .. } => (),
+        //~^ rest_when_destructuring_struct
+    }
+
+    match e {
+        E::A { a1: _, a2: _ } => (),
+        E::B { b1, b2: _ } => (),
+    }
+}

tests/ui/rest_when_destructuring_struct.stderr

@@ -0,0 +1,20 @@
+error: struct destructuring with rest (..)
+  --> tests/ui/rest_when_destructuring_struct.rs:19: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)]`
+
+error: struct destructuring with rest (..)
+  --> tests/ui/rest_when_destructuring_struct.rs:26:9
+   |
+LL |         E::B { .. } => (),
+   |         ^^^^^^^^^^^
+   |
+   = help: consider explicitly ignoring remaining fields with wildcard patterns (x: _)
+
+error: aborting due to 2 previous errors
+