clean-up

Author: ada4a

clippy_lints/src/needless_arbitrary_self_type.rs

@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use rustc_ast::ast::{BindingMode, ByRef, Lifetime, Mutability, Param, PatKind, Path, TyKind};
+use rustc_ast::ast::{BindingMode, ByRef, Lifetime, Mutability, Param, PatKind, TyKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
 use rustc_span::symbol::kw;
 
 declare_clippy_lint! {
@@ -65,73 +64,69 @@ enum Mode {
     Value,
 }
 
-fn check_param_inner(cx: &EarlyContext<'_>, path: &Path, span: Span, binding_mode: &Mode, mutbl: Mutability) {
-    if let [segment] = &path.segments[..]
-        && segment.ident.name == kw::SelfUpper
-    {
-        // In case we have a named lifetime, we check if the name comes from expansion.
-        // If it does, at this point we know the rest of the parameter was written by the user,
-        // so let them decide what the name of the lifetime should be.
-        // See #6089 for more details.
-        let mut applicability = Applicability::MachineApplicable;
-        let self_param = match (binding_mode, mutbl) {
-            (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
-            (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
-                if lifetime.ident.span.from_expansion() {
-                    applicability = Applicability::HasPlaceholders;
-                    "&'_ mut self".to_string()
-                } else {
-                    let lt_name = snippet_with_applicability(cx, lifetime.ident.span, "..", &mut applicability);
-                    format!("&{lt_name} mut self")
-                }
-            },
-            (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
-            (Mode::Ref(Some(lifetime)), Mutability::Not) => {
-                if lifetime.ident.span.from_expansion() {
-                    applicability = Applicability::HasPlaceholders;
-                    "&'_ self".to_string()
-                } else {
-                    let lt_name = snippet_with_applicability(cx, lifetime.ident.span, "..", &mut applicability);
-                    format!("&{lt_name} self")
-                }
-            },
-            (Mode::Value, Mutability::Mut) => "mut self".to_string(),
-            (Mode::Value, Mutability::Not) => "self".to_string(),
-        };
-
-        span_lint_and_sugg(
-            cx,
-            NEEDLESS_ARBITRARY_SELF_TYPE,
-            span,
-            "the type of the `self` parameter does not need to be arbitrary",
-            "consider to change this parameter to",
-            self_param,
-            applicability,
-        );
-    }
-}
-
 impl EarlyLintPass for NeedlessArbitrarySelfType {
     fn check_param(&mut self, cx: &EarlyContext<'_>, p: &Param) {
         // Bail out if the parameter it's not a receiver or was not written by the user
         if !p.is_self() || p.span.from_expansion() {
             return;
         }
 
-        match &p.ty.kind {
-            TyKind::Path(None, path) => {
-                if let PatKind::Ident(BindingMode(ByRef::No, mutbl), _, _) = p.pat.kind {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Value, mutbl);
-                }
+        let (path, binding_mode, mutbl) = match &p.ty.kind {
+            TyKind::Path(None, path) if let PatKind::Ident(BindingMode(ByRef::No, mutbl), _, _) = p.pat.kind => {
+                (path, Mode::Value, mutbl)
             },
-            TyKind::Ref(lifetime, mut_ty) => {
+            TyKind::Ref(lifetime, mut_ty)
                 if let TyKind::Path(None, path) = &mut_ty.ty.kind
-                    && let PatKind::Ident(BindingMode::NONE, _, _) = p.pat.kind
-                {
-                    check_param_inner(cx, path, p.span.to(p.ty.span), &Mode::Ref(*lifetime), mut_ty.mutbl);
-                }
+                    && let PatKind::Ident(BindingMode::NONE, _, _) = p.pat.kind =>
+            {
+                (path, Mode::Ref(*lifetime), mut_ty.mutbl)
             },
-            _ => {},
+            _ => return,
+        };
+
+        let span = p.span.to(p.ty.span);
+        if let [segment] = &path.segments[..]
+            && segment.ident.name == kw::SelfUpper
+        {
+            // In case we have a named lifetime, we check if the name comes from expansion.
+            // If it does, at this point we know the rest of the parameter was written by the user,
+            // so let them decide what the name of the lifetime should be.
+            // See #6089 for more details.
+            let mut applicability = Applicability::MachineApplicable;
+            let self_param = match (binding_mode, mutbl) {
+                (Mode::Ref(None), Mutability::Mut) => "&mut self".to_string(),
+                (Mode::Ref(Some(lifetime)), Mutability::Mut) => {
+                    if lifetime.ident.span.from_expansion() {
+                        applicability = Applicability::HasPlaceholders;
+                        "&'_ mut self".to_string()
+                    } else {
+                        let lt_name = snippet_with_applicability(cx, lifetime.ident.span, "'_", &mut applicability);
+                        format!("&{lt_name} mut self")
+                    }
+                },
+                (Mode::Ref(None), Mutability::Not) => "&self".to_string(),
+                (Mode::Ref(Some(lifetime)), Mutability::Not) => {
+                    if lifetime.ident.span.from_expansion() {
+                        applicability = Applicability::HasPlaceholders;
+                        "&'_ self".to_string()
+                    } else {
+                        let lt_name = snippet_with_applicability(cx, lifetime.ident.span, "'_", &mut applicability);
+                        format!("&{lt_name} self")
+                    }
+                },
+                (Mode::Value, Mutability::Mut) => "mut self".to_string(),
+                (Mode::Value, Mutability::Not) => "self".to_string(),
+            };
+
+            span_lint_and_sugg(
+                cx,
+                NEEDLESS_ARBITRARY_SELF_TYPE,
+                span,
+                "the type of the `self` parameter does not need to be arbitrary",
+                "consider to change this parameter to",
+                self_param,
+                applicability,
+            );
         }
     }
 }