clean-up

Author: ada4a

clippy_lints/src/matches/match_as_ref.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::ty::option_arg_ty;
 use clippy_utils::{is_none_arm, peel_blocks};
 use rustc_errors::Applicability;
 use rustc_hir::{Arm, BindingMode, ByRef, Expr, ExprKind, LangItem, Mutability, PatKind, QPath};
@@ -10,54 +11,53 @@ use rustc_middle::ty;
 use super::MATCH_AS_REF;
 
 pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr: &Expr<'_>) {
-    if arms.len() == 2 && arms[0].guard.is_none() && arms[1].guard.is_none() {
-        let arm_ref_mut = if is_none_arm(cx, &arms[0]) {
-            is_ref_some_arm(cx, &arms[1])
-        } else if is_none_arm(cx, &arms[1]) {
-            is_ref_some_arm(cx, &arms[0])
+    if let [arm1, arm2] = arms
+        && arm1.guard.is_none()
+        && arm2.guard.is_none()
+        && let Some(arm_ref_mutbl) = if is_none_arm(cx, arm1) {
+            as_ref_some_arm(cx, arm2)
+        } else if is_none_arm(cx, arm2) {
+            as_ref_some_arm(cx, arm1)
         } else {
             None
+        }
+    {
+        let method = match arm_ref_mutbl {
+            Mutability::Not => "as_ref",
+            Mutability::Mut => "as_mut",
         };
-        if let Some(rb) = arm_ref_mut {
-            let suggestion = match rb {
-                Mutability::Not => "as_ref",
-                Mutability::Mut => "as_mut",
-            };
 
-            let output_ty = cx.typeck_results().expr_ty(expr);
-            let input_ty = cx.typeck_results().expr_ty(ex);
+        let output_ty = cx.typeck_results().expr_ty(expr);
+        let input_ty = cx.typeck_results().expr_ty(ex);
 
-            let cast = if let ty::Adt(_, args) = input_ty.kind()
-                && let input_ty = args.type_at(0)
-                && let ty::Adt(_, args) = output_ty.kind()
-                && let output_ty = args.type_at(0)
-                && let ty::Ref(_, output_ty, _) = *output_ty.kind()
-                && input_ty != output_ty
-            {
-                ".map(|x| x as _)"
-            } else {
-                ""
-            };
+        let cast = if let Some(input_ty) = option_arg_ty(cx, input_ty)
+            && let Some(output_ty) = option_arg_ty(cx, output_ty)
+            && let ty::Ref(_, output_ty, _) = *output_ty.kind()
+            && input_ty != output_ty
+        {
+            ".map(|x| x as _)"
+        } else {
+            ""
+        };
 
-            let mut applicability = Applicability::MachineApplicable;
-            span_lint_and_sugg(
-                cx,
-                MATCH_AS_REF,
-                expr.span,
-                format!("use `{suggestion}()` instead"),
-                "try",
-                format!(
-                    "{}.{suggestion}(){cast}",
-                    snippet_with_applicability(cx, ex.span, "_", &mut applicability),
-                ),
-                applicability,
-            );
-        }
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            MATCH_AS_REF,
+            expr.span,
+            format!("use `{method}()` instead"),
+            "try",
+            format!(
+                "{}.{method}(){cast}",
+                snippet_with_applicability(cx, ex.span, "_", &mut applicability),
+            ),
+            applicability,
+        );
     }
 }
 
 // Checks if arm has the form `Some(ref v) => Some(v)` (checks for `ref` and `ref mut`)
-fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
+fn as_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
     if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind
         && cx
             .qpath_res(qpath, arm.pat.hir_id)