lint struct_fields_rest_default only detect derive Default now

WeiTheShinobi · WeiTheShinobi · commit 7f6385187ce5 · 2025-03-30T21:20:22.000+08:00
diff --git a/clippy_lints/src/struct_fields_rest_default.rs b/clippy_lints/src/struct_fields_rest_default.rs
@@ -1,19 +1,27 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::is_trait_item;
 use clippy_utils::source::snippet;
-use rustc_hir::{ExprKind, StructTailExpr};
+
+use rustc_hir::{ExprKind, QPath, StructTailExpr};
 use rustc_lint::{LateLintPass, LintContext};
+use rustc_middle::ty;
 use rustc_session::declare_lint_pass;
-use rustc_span::sym;
+use rustc_span::{Symbol, sym};
 
 declare_clippy_lint! {
     /// ### What it does
-    /// Check struct initialization uses `..*::default()` pattern to skip rest of struct field initialization.
+    /// Check if struct initialization uses derive `Default` with `..*::default()` pattern
+    /// to skip rest of struct field initialization.
     ///
     /// ### Why restrict this?
     /// Using `..*::default()` can hide field initialization when new fields are added to structs,
     /// potentially leading to bugs where developers forget to explicitly set values for new fields.
     ///
+    /// ### Limitations
+    /// Only check the derive `Default` with `..*::default()` pattern,
+    /// because when developer manually implements `Default` or uses other base value,
+    /// it means that they know what they are doing rather than just being lazy.
+    ///
     /// ### Example
     /// ```no_run
     /// #[derive(Default)]
@@ -70,16 +78,17 @@ declare_lint_pass!(StructFieldsDefault => [STRUCT_FIELDS_REST_DEFAULT]);
 impl<'tcx> LateLintPass<'tcx> for StructFieldsDefault {
     fn check_expr(&mut self, cx: &rustc_lint::LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
         if !expr.span.in_external_macro(cx.sess().source_map())
-            && let ExprKind::Struct(_, _, StructTailExpr::Base(base)) = &expr.kind
+            && let ExprKind::Struct(QPath::Resolved(_, _), _, StructTailExpr::Base(base)) = &expr.kind
             && let ExprKind::Call(func, _) = base.kind
             && is_trait_item(cx, func, sym::Default)
+            && is_struct_trait_from_derive(cx, expr, sym::Default)
         {
             span_lint_and_help(
                 cx,
                 STRUCT_FIELDS_REST_DEFAULT,
                 base.span,
                 format!(
-                    "should not use `..{}` to omit rest of struct field initialization",
+                    "usage of `..{}` to initialize struct fields",
                     snippet(cx, base.span, "")
                 ),
                 Some(expr.span),
@@ -88,3 +97,25 @@ impl<'tcx> LateLintPass<'tcx> for StructFieldsDefault {
         }
     }
 }
+
+fn is_struct_trait_from_derive<'tcx>(
+    cx: &rustc_lint::LateContext<'tcx>,
+    expr: &'tcx rustc_hir::Expr<'tcx>,
+    trait_item: Symbol,
+) -> bool {
+    if let Some(default_trait_id) = cx.tcx.get_diagnostic_item(trait_item) {
+        let impls = cx.tcx.trait_impls_of(default_trait_id);
+        for (impl_ty, impl_def_ids) in impls.non_blanket_impls() {
+            if let Some(impl_struct_def_id) = impl_ty.def()
+                && let ty::Adt(curr_struct, _) = cx.typeck_results().expr_ty(expr).kind()
+                && curr_struct.did() == impl_struct_def_id
+            {
+                // we found the struct what we need, skip the rest.
+                return impl_def_ids
+                    .iter()
+                    .any(|&impl_def_id| cx.tcx.is_automatically_derived(impl_def_id));
+            }
+        }
+    }
+    false
+}
diff --git a/tests/ui/struct_fields_rest_default.rs b/tests/ui/struct_fields_rest_default.rs
@@ -3,56 +3,97 @@
 extern crate proc_macros;
 
 #[derive(Default)]
-struct Foo {
+struct DeriveCase {
     a: i32,
     b: i32,
     c: i32,
 }
 
-impl Foo {
-    fn get_foo() -> Self {
-        Foo { a: 0, b: 0, c: 0 }
+impl DeriveCase {
+    fn get_derive_case() -> Self {
+        DeriveCase { a: 0, b: 0, c: 0 }
+    }
+}
+
+struct ManuallyCase {
+    a: i32,
+    b: i32,
+    c: i32,
+}
+
+impl Default for ManuallyCase {
+    fn default() -> Self {
+        ManuallyCase { a: 10, b: 20, c: 30 }
     }
 }
 
 fn main() {
     #[rustfmt::skip]
-    let _ = Foo {
+    let _ = DeriveCase {
         a: 10,
         ..Default::default()
         //~^ struct_fields_rest_default
     };
 
     #[rustfmt::skip]
-    let _ = Foo {
+    let _ = DeriveCase {
         a: 10,
-        ..Foo::default()
+        ..DeriveCase::default()
         //~^ struct_fields_rest_default
     };
 
     // should not lint
-    #[rustfmt::skip]
-    let _ = Foo {
+    let _ = DeriveCase {
+        a: 10,
+        ..DeriveCase::get_derive_case()
+    };
+
+    // ------- ManuallyCase -------
+    // should not lint manually default
+    let _ = ManuallyCase {
+        a: 10,
+        ..Default::default()
+    };
+
+    // should not lint manually default
+    let _ = ManuallyCase {
         a: 10,
-        ..Foo::get_foo()
+        ..ManuallyCase::default()
     };
+    // ----------------------------
 
     // should not lint in external macro
     proc_macros::external! {
         #[derive(Default)]
-        struct ExternalDefault {
+        struct ExternalDeriveCase {
             a: i32,
             b: i32,
         }
 
-        let _ = ExternalDefault {
+        let _ = ExternalDeriveCase {
+            a: 10,
+            ..Default::default()
+        };
+
+        struct ExternalManuallyCase {
+            a: i32,
+            b: i32,
+        }
+
+        impl Default for ExternalManuallyCase {
+            fn default() -> Self {
+                ExternalManuallyCase { a: 10, b: 20 }
+            }
+        }
+
+        let _ = ExternalManuallyCase {
             a: 10,
             ..Default::default()
         };
     }
 
     // should not lint
-    let _ = Foo {
+    let _ = DeriveCase {
         a: Default::default(),
         b: Default::default(),
         c: Default::default(),
diff --git a/tests/ui/struct_fields_rest_default.stderr b/tests/ui/struct_fields_rest_default.stderr
@@ -1,13 +1,13 @@
-error: should not use `..Default::default()` to omit rest of struct field initialization
-  --> tests/ui/struct_fields_rest_default.rs:22:11
+error: usage of `..Default::default()` to initialize struct fields
+  --> tests/ui/struct_fields_rest_default.rs:34:11
    |
 LL |         ..Default::default()
    |           ^^^^^^^^^^^^^^^^^^
    |
 help: explicitly specify all fields or use other base value instead of `..*::default()`
-  --> tests/ui/struct_fields_rest_default.rs:20:13
+  --> tests/ui/struct_fields_rest_default.rs:32:13
    |
-LL |       let _ = Foo {
+LL |       let _ = DeriveCase {
    |  _____________^
 LL | |         a: 10,
 LL | |         ..Default::default()
@@ -17,19 +17,19 @@ LL | |     };
    = note: `-D clippy::struct-fields-rest-default` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::struct_fields_rest_default)]`
 
-error: should not use `..Foo::default()` to omit rest of struct field initialization
-  --> tests/ui/struct_fields_rest_default.rs:29:11
+error: usage of `..DeriveCase::default()` to initialize struct fields
+  --> tests/ui/struct_fields_rest_default.rs:41:11
    |
-LL |         ..Foo::default()
-   |           ^^^^^^^^^^^^^^
+LL |         ..DeriveCase::default()
+   |           ^^^^^^^^^^^^^^^^^^^^^
    |
 help: explicitly specify all fields or use other base value instead of `..*::default()`
-  --> tests/ui/struct_fields_rest_default.rs:27:13
+  --> tests/ui/struct_fields_rest_default.rs:39:13
    |
-LL |       let _ = Foo {
+LL |       let _ = DeriveCase {
    |  _____________^
 LL | |         a: 10,
-LL | |         ..Foo::default()
+LL | |         ..DeriveCase::default()
 LL | |
 LL | |     };
    | |_____^
