fix: derivable_impls FN when enum is qualified with Self

Author: profetia

clippy_lints/src/derivable_impls.rs

@@ -10,7 +10,7 @@ use rustc_hir::{
 };
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::adjustment::{Adjust, PointerCoercion};
-use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults};
+use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty, TypeckResults, VariantDef};
 use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
@@ -161,17 +161,42 @@ fn check_struct<'tcx>(
     }
 }
 
-fn check_enum<'tcx>(
+fn extract_enum_variant<'tcx>(
     cx: &LateContext<'tcx>,
-    item: &'tcx Item<'_>,
-    func_expr: &Expr<'_>,
-    adt_def: AdtDef<'_>,
-    is_const: bool,
-) {
-    if let ExprKind::Path(QPath::Resolved(None, p)) = &peel_blocks(func_expr).kind
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
+) -> Option<&'tcx VariantDef> {
+    let func_expr = peel_blocks(func_expr);
+    if let ExprKind::Path(QPath::Resolved(None, p)) = &func_expr.kind
         && let Res::Def(DefKind::Ctor(CtorOf::Variant, CtorKind::Const), id) = p.res
         && let variant_id = cx.tcx.parent(id)
         && let Some(variant_def) = adt_def.variants().iter().find(|v| v.def_id == variant_id)
+    {
+        return Some(variant_def);
+    }
+
+    if let ExprKind::Path(QPath::TypeRelative(ty, segment)) = &func_expr.kind
+        && let TyKind::Path(QPath::Resolved(None, p)) = &ty.kind
+        && let Res::SelfTyAlias {
+            is_trait_impl: true, ..
+        } = p.res
+        && let variant_ident = segment.ident
+        && let Some(variant_def) = adt_def.variants().iter().find(|v| v.ident(cx.tcx) == variant_ident)
+    {
+        return Some(variant_def);
+    }
+
+    None
+}
+
+fn check_enum<'tcx>(
+    cx: &LateContext<'tcx>,
+    item: &'tcx Item<'tcx>,
+    func_expr: &'tcx Expr<'tcx>,
+    adt_def: AdtDef<'tcx>,
+    is_const: bool,
+) {
+    if let Some(variant_def) = extract_enum_variant(cx, func_expr, adt_def)
         && variant_def.fields.is_empty()
         && !variant_def.is_field_list_non_exhaustive()
     {

tests/ui/derivable_impls.fixed

@@ -352,4 +352,16 @@ mod issue15493 {
     }
 }
 
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    #[derive(Default)]
+    enum Bar {
+        #[default]
+        A,
+        B,
+    }
+
+    
+}
+
 fn main() {}

tests/ui/derivable_impls.rs

@@ -422,4 +422,19 @@ mod issue15493 {
     }
 }
 
+mod issue15536 {
+    #[derive(Copy, Clone)]
+    enum Bar {
+        A,
+        B,
+    }
+
+    impl Default for Bar {
+        //~^ derivable_impls
+        fn default() -> Self {
+            Self::A
+        }
+    }
+}
+
 fn main() {}

tests/ui/derivable_impls.stderr

@@ -187,5 +187,28 @@ LL ~     #[default]
 LL ~     Bar,
    |
 
-error: aborting due to 11 previous errors
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:432:5
+   |
+LL | /     impl Default for Bar {
+LL | |
+LL | |         fn default() -> Self {
+LL | |             Self::A
+LL | |         }
+LL | |     }
+   | |_____^
+   |
+help: replace the manual implementation with a derive attribute and mark the default variant
+   |
+LL ~     #[derive(Default)]
+LL ~     enum Bar {
+LL ~         #[default]
+LL ~         A,
+LL |         B,
+LL |     }
+LL |
+LL ~     
+   |
+
+error: aborting due to 12 previous errors