some code detection and suggestions

Author: nyurik

clippy_lints/src/new_without_default.rs

@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::return_ty;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::DiagExt;
+use clippy_utils::{is_default_equivalent_call, return_ty};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::HirIdMap;
@@ -134,7 +134,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                     if impl_item.span.in_external_macro(cx.sess().source_map()) {
                         return;
                     }
-                    if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind {
+                    if let hir::ImplItemKind::Fn(ref sig, body_id) = impl_item.kind {
                         let name = impl_item.ident.name;
                         let id = impl_item.owner_id;
                         if sig.header.is_unsafe() {
@@ -199,9 +199,31 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
                                     return;
                                 }
                                 suggest_new_without_default(cx, item, impl_item, id, self_ty, generics, impl_self_ty);
-                            } else {
+                            } else if let hir::ExprKind::Block(block, _) = cx.tcx.hir().body(body_id).value.kind {
                                 // this type has an automatically derived `Default` implementation
                                 // check if `new` and `default` are equivalent
+                                if !check_block_calls_default(cx, block) {
+                                    let self_ty_fmt = self_ty.to_string();
+                                    let self_type_snip = snippet(cx, impl_self_ty.span, &self_ty_fmt);
+                                    span_lint_hir_and_then(
+                                        cx,
+                                        DEFAULT_MISMATCHES_NEW,
+                                        id.into(),
+                                        impl_item.span,
+                                        format!(
+                                            "you should consider delegating to the auto-derived `Default` for `{self_type_snip}`"
+                                        ),
+                                        |diag| {
+                                            diag.suggest_prepend_item(
+                                                cx,
+                                                block.span,
+                                                "try using this",
+                                                &"Self::default()",
+                                                Applicability::MaybeIncorrect,
+                                            );
+                                        },
+                                    );
+                                }
                             }
                         }
                     }
@@ -211,14 +233,55 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault {
     }
 }
 
+/// Check if a block contains one of these:
+/// - Empty block with an expr (e.g., `{ Self::default() }`)
+/// - One statement (e.g., `{ return Self::default(); }`)
+fn check_block_calls_default(cx: &LateContext<'_>, block: &hir::Block<'_>) -> bool {
+    if let Some(expr) = block.expr
+        && block.stmts.is_empty()
+    {
+        // Check the block's trailing expression (e.g., `Self::default()`)
+        check_expr_call_default(cx, expr)
+    } else if let [hir::Stmt { kind, .. }] = block.stmts
+        && let hir::StmtKind::Expr(expr) | hir::StmtKind::Semi(expr) = kind
+    {
+        // Check if the single statement is a return or expr
+        match expr.kind {
+            // Case 1: `return Self::default();`
+            hir::ExprKind::Ret(Some(ret_expr)) => check_expr_call_default(cx, ret_expr),
+            // Case 2: `Self::default()` (possibly inside a block)
+            hir::ExprKind::Block(block, _) => check_block_calls_default(cx, block),
+            // Case 3: Direct call (e.g., `Self::default()` as the entire body)
+            _ => check_expr_call_default(cx, expr),
+        }
+    } else {
+        false
+    }
+}
+
+/// Check for `Self::default()` call syntax or equivalent
+fn check_expr_call_default(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
+    if let hir::ExprKind::Call(callee, args) = expr.kind
+        && args.is_empty()
+        // FIXME: does this include `Self { }` style calls, which is equivalent,
+        //        but not the same as `Self::default()`?
+        // FIXME: what should the whole_call_expr (3rd arg) be?
+        && is_default_equivalent_call(cx, callee, None)
+    {
+        true
+    } else {
+        false
+    }
+}
+
 fn suggest_new_without_default<'tcx>(
     cx: &LateContext<'tcx>,
-    item: &rustc_hir::Item<'_>,
-    impl_item: &rustc_hir::ImplItem<'_>,
-    id: rustc_hir::OwnerId,
+    item: &hir::Item<'_>,
+    impl_item: &hir::ImplItem<'_>,
+    id: hir::OwnerId,
     self_ty: Ty<'tcx>,
-    generics: &rustc_hir::Generics<'_>,
-    impl_self_ty: &rustc_hir::Ty<'_>,
+    generics: &hir::Generics<'_>,
+    impl_self_ty: &hir::Ty<'_>,
 ) {
     let generics_sugg = snippet(cx, generics.span, "");
     let where_clause_sugg = if generics.has_where_clause_predicates {
@@ -239,23 +302,15 @@ fn suggest_new_without_default<'tcx>(
                 cx,
                 item.span,
                 "try adding this",
-                &create_new_without_default_suggest_msg(&self_type_snip, &generics_sugg, &where_clause_sugg),
+                &format!(
+                    "impl{generics_sugg} Default for {self_type_snip}{where_clause_sugg} {{
+    fn default() -> Self {{
+        Self::new()
+    }}
+}}"
+                ),
                 Applicability::MachineApplicable,
             );
         },
     );
 }
-
-fn create_new_without_default_suggest_msg(
-    self_type_snip: &str,
-    generics_sugg: &str,
-    where_clause_sugg: &str,
-) -> String {
-    #[rustfmt::skip]
-    format!(
-"impl{generics_sugg} Default for {self_type_snip}{where_clause_sugg} {{
-    fn default() -> Self {{
-        Self::new()
-    }}
-}}")
-}

tests/ui/default_mismatches_new.fixed

@@ -1,13 +1,9 @@
+#![allow(clippy::needless_return)]
 #![warn(clippy::default_mismatches_new)]
 
-#[derive(Default)]
-struct WithDeriveDefault(i32);
-impl WithDeriveDefault {
-    pub fn new() -> Self {
-        Self(42)
-    }
-}
-
+//
+// Nothing to change
+//
 struct WithManualDefault(i32);
 impl WithManualDefault {
     pub fn new() -> Self {
@@ -20,21 +16,115 @@ impl Default for WithManualDefault {
     }
 }
 
-fn main() {}
+#[derive(Default)]
+struct WithCallToDefaultDefault(i32);
+impl WithCallToDefaultDefault {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
 
-/*
+#[derive(Default)]
+struct WithCallToSelfDefault(i32);
+impl WithCallToSelfDefault {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
 
-   DELETE THE FOLLOWING CODE.
+#[derive(Default)]
+struct WithCallToTypeDefault(i32);
+impl WithCallToTypeDefault {
+    pub fn new() -> Self {
+        WithCallToTypeDefault::default()
+    }
+}
 
-   We only need it until the default_mismatches_new lint is implemented.
+#[derive(Default)]
+struct WithCallToFullTypeDefault(i32);
+impl WithCallToFullTypeDefault {
+    pub fn new() -> Self {
+        crate::WithCallToFullTypeDefault::default()
+    }
+}
 
-*/
-pub struct Foo;
+#[derive(Default)]
+struct WithReturnCallToSelfDefault(i32);
+impl WithReturnCallToSelfDefault {
+    pub fn new() -> Self {
+        return Self::default();
+    }
+}
 
-impl Foo {
-    pub fn new() -> Foo {
-        //~^ new_without_default
+//
+// Offer suggestions
+//
 
-        Foo
+#[derive(Default)]
+struct WithDeriveDefault;
+impl WithDeriveDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        Self
     }
 }
+
+#[derive(Default)]
+struct WithDeriveTypeDefault;
+impl WithDeriveTypeDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        return crate::WithDeriveTypeDefault;
+    }
+}
+
+#[derive(Default)]
+struct WithDeriveIntDefault {
+    value: i32,
+}
+impl WithDeriveIntDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        Self { value: 0 }
+    }
+}
+
+#[derive(Default)]
+struct WithDeriveTupleDefault(i32);
+impl WithDeriveTupleDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        Self(0)
+    }
+}
+
+#[derive(Default)]
+struct WithNonZeroDeriveDefault(i32);
+impl WithNonZeroDeriveDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        Self(42)
+    }
+}
+
+#[derive(Default)]
+struct WithExtraBlockDefault(i32);
+impl WithExtraBlockDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        { Self::default() }
+    }
+}
+
+#[derive(Default)]
+struct WithExtraBlockRetDefault(i32);
+impl WithExtraBlockRetDefault {
+    pub fn new() -> Self {
+        //~^ default_mismatches_new
+        {
+            return Self::default();
+        }
+    }
+}
+
+fn main() {}