Also lint enums with type parameters with unit variant default

Author: estebank

compiler/rustc_lint/src/default_could_be_derived.rs

@@ -50,9 +50,13 @@ impl<'tcx> LateLintPass<'tcx> for DefaultCouldBeDerived {
         }
         let hir_self_ty = data.self_ty;
         let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = hir_self_ty.kind else { return };
-        let Res::Def(_, type_def_id) = path.res else { return };
+        let Res::Def(def_kind, type_def_id) = path.res else { return };
         let generics = cx.tcx.generics_of(type_def_id);
-        if !generics.own_params.is_empty() {
+        if !generics.own_params.is_empty() && def_kind != DefKind::Enum {
+            // For enums, `#[derive(Default)]` forces you to select a unit variant to avoid
+            // "imperfect derives", unnecessary bounds on type parameters, so even if the enum has
+            // type parameters we can still lint on the manual impl if the return is a unit
+            // variant.
             return;
         }
         // We have a manual `impl Default for Ty {}` item, where `Ty` has no type parameters.

tests/ui/structs/manual-default-impl-could-be-derived.rs

@@ -55,20 +55,20 @@ impl Default for E { //~ ERROR
 }
 
 // Detection of unit variant ctors that could have been marked `#[default]`.
-enum F {
+enum F<T> {
     Unit,
-    Tuple(i32),
+    Tuple(T),
 }
 
-impl Default for F { //~ ERROR
+impl<T> Default for F<T> { //~ ERROR
     fn default() -> Self {
         F::Unit
     }
 }
 
 // Comparison of `impl` *fields* with their `Default::default()` bodies.
 struct G {
-    f: F,
+    f: F<i32>,
 }
 
 impl Default for G { //~ ERROR
@@ -85,6 +85,6 @@ fn main() {
 //    let _ = C::default();
     let _ = D::default();
     let _ = E::default();
-    let _ = F::default();
+    let _ = F::<i32>::default();
     let _ = G::default();
 }

tests/ui/structs/manual-default-impl-could-be-derived.stderr

@@ -40,7 +40,7 @@ LL ~ #[derive(Default)] struct E {
 error: `impl Default` that could be derived
   --> $DIR/manual-default-impl-could-be-derived.rs:63:1
    |
-LL | / impl Default for F {
+LL | / impl<T> Default for F<T> {
 LL | |     fn default() -> Self {
 LL | |         F::Unit
 LL | |     }
@@ -49,7 +49,7 @@ LL | | }
    |
 help: you don't need to manually `impl Default`, you can derive it
    |
-LL ~ #[derive(Default)] enum F {
+LL ~ #[derive(Default)] enum F<T> {
 LL ~     #[default] Unit,
    |