allow when Partial::eq is const

turns out `is_in_const_context` wasn't even supposed to be put in the
main let-chain, since it's only relevant for the
`is_structural_partial_eq` case

Co-authored-by: yanglsh <[email protected]>

Author: ada4a

clippy_lints/src/equatable_if_let.rs

@@ -1,12 +1,15 @@
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_in_const_context;
+use clippy_utils::msrvs::Msrv;
+use clippy_utils::qualify_min_const_fn::is_stable_const_fn;
 use clippy_utils::source::snippet_with_context;
 use clippy_utils::ty::implements_trait;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, Pat, PatKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::Ty;
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -38,7 +41,17 @@ declare_clippy_lint! {
     "using pattern matching instead of equality"
 }
 
-declare_lint_pass!(PatternEquality => [EQUATABLE_IF_LET]);
+impl_lint_pass!(PatternEquality => [EQUATABLE_IF_LET]);
+
+pub(super) struct PatternEquality {
+    msrv: Msrv,
+}
+
+impl PatternEquality {
+    pub(super) fn new(conf: &Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
 
 /// detects if pattern matches just one thing
 fn unary_pattern(pat: &Pat<'_>) -> bool {
@@ -61,9 +74,22 @@ fn unary_pattern(pat: &Pat<'_>) -> bool {
     }
 }
 
-fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool {
-    if let Some(def_id) = cx.tcx.lang_items().eq_trait() {
-        implements_trait(cx, ty, def_id, &[other.into()])
+fn is_structural_partial_eq<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>, msrv: Msrv) -> bool {
+    if let Some(eq_trait) = cx.tcx.lang_items().eq_trait()
+        && implements_trait(cx, ty, eq_trait, &[other.into()])
+    {
+        if !is_in_const_context(cx) {
+            return true;
+        }
+
+        // TODO: add a MSRV test once `eq` becomes stably-const
+        if let Some(eq_method) = cx.tcx.provided_trait_methods(eq_trait).next()
+            && is_stable_const_fn(cx, eq_method.def_id, msrv)
+        {
+            true
+        } else {
+            false
+        }
     } else {
         false
     }
@@ -106,13 +132,12 @@ impl<'tcx> LateLintPass<'tcx> for PatternEquality {
         if let ExprKind::Let(let_expr) = expr.kind
             && unary_pattern(let_expr.pat)
             && !expr.span.in_external_macro(cx.sess().source_map())
-            && !is_in_const_context(cx)
         {
             let exp_ty = cx.typeck_results().expr_ty(let_expr.init);
             let pat_ty = cx.typeck_results().pat_ty(let_expr.pat);
             let mut applicability = Applicability::MachineApplicable;
 
-            if is_structural_partial_eq(cx, exp_ty, pat_ty) && !contains_type_mismatch(cx, let_expr.pat) {
+            if is_structural_partial_eq(cx, exp_ty, pat_ty, self.msrv) && !contains_type_mismatch(cx, let_expr.pat) {
                 let pat_str = match let_expr.pat.kind {
                     PatKind::Struct(..) => format!(
                         "({})",

clippy_lints/src/lib.rs

@@ -647,7 +647,7 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
     store.register_late_pass(move |_| Box::new(large_futures::LargeFuture::new(conf)));
     store.register_late_pass(|_| Box::new(if_let_mutex::IfLetMutex));
     store.register_late_pass(|_| Box::new(if_not_else::IfNotElse));
-    store.register_late_pass(|_| Box::new(equatable_if_let::PatternEquality));
+    store.register_late_pass(|_| Box::new(equatable_if_let::PatternEquality::new(conf)));
     store.register_late_pass(|_| Box::new(manual_async_fn::ManualAsyncFn));
     store.register_late_pass(|_| Box::new(panic_in_result_fn::PanicInResultFn));
     store.register_early_pass(move || Box::new(non_expressive_names::NonExpressiveNames::new(conf)));

tests/ui/equatable_if_let.fixed

@@ -142,5 +142,6 @@ mod issue8710 {
 
 fn issue15376() {
     // PartialEq is not stable in consts yet
-    const _: u32 = if let Some(true) = None { 0 } else { 1 };
+    const _: u32 = if matches!(None, Some(true)) { 0 } else { 1 };
+    //~^ ERROR: this pattern matching can be expressed using `matches!`
 }

tests/ui/equatable_if_let.rs

@@ -143,4 +143,5 @@ mod issue8710 {
 fn issue15376() {
     // PartialEq is not stable in consts yet
     const _: u32 = if let Some(true) = None { 0 } else { 1 };
+    //~^ ERROR: this pattern matching can be expressed using `matches!`
 }

tests/ui/equatable_if_let.stderr

@@ -103,5 +103,11 @@ error: this pattern matching can be expressed using `matches!`
 LL |         if let Some(MyEnum::B) = get_enum() {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(get_enum(), Some(MyEnum::B))`
 
-error: aborting due to 17 previous errors
+error: this pattern matching can be expressed using `matches!`
+  --> tests/ui/equatable_if_let.rs:145:23
+   |
+LL |     const _: u32 = if let Some(true) = None { 0 } else { 1 };
+   |                       ^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(None, Some(true))`
+
+error: aborting due to 18 previous errors