Move type-checking logic in StaticConst to RedundantStaticLifetime.

rust-lang · Jun 14, 2019 · ff1b533 · ff1b533
1 parent 16bd479
commit ff1b533
Show file tree

Hide file tree

Showing 3 changed files with 63 additions and 47 deletions.
diff --git a/clippy_lints/src/const_static_lifetime.rs b/clippy_lints/src/const_static_lifetime.rs
@@ -1,7 +1,7 @@
-use crate::utils::{in_macro_or_desugar, snippet, span_lint_and_then};
+use crate::redundant_static_lifetime::RedundantStaticLifetime;
+use crate::utils::in_macro_or_desugar;
 use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
 use rustc::{declare_lint_pass, declare_tool_lint};
-use rustc_errors::Applicability;
 use syntax::ast::*;
 
 declare_clippy_lint! {
@@ -31,51 +31,9 @@ declare_lint_pass!(StaticConst => [CONST_STATIC_LIFETIME]);
 impl StaticConst {
     // Recursively visit types
     fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>) {
-        match ty.node {
-            // Be careful of nested structures (arrays and tuples)
-            TyKind::Array(ref ty, _) => {
-                self.visit_type(&*ty, cx);
-            },
-            TyKind::Tup(ref tup) => {
-                for tup_ty in tup {
-                    self.visit_type(&*tup_ty, cx);
-                }
-            },
-            // This is what we are looking for !
-            TyKind::Rptr(ref optional_lifetime, ref borrow_type) => {
-                // Match the 'static lifetime
-                if let Some(lifetime) = *optional_lifetime {
-                    match borrow_type.ty.node {
-                        TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
-                            if lifetime.ident.name == syntax::symbol::kw::StaticLifetime {
-                                let snip = snippet(cx, borrow_type.ty.span, "<type>");
-                                let sugg = format!("&{}", snip);
-                                span_lint_and_then(
-                                    cx,
-                                    CONST_STATIC_LIFETIME,
-                                    lifetime.ident.span,
-                                    "Constants have by default a `'static` lifetime",
-                                    |db| {
-                                        db.span_suggestion(
-                                            ty.span,
-                                            "consider removing `'static`",
-                                            sugg,
-                                            Applicability::MachineApplicable, //snippet
-                                        );
-                                    },
-                                );
-                            }
-                        },
-                        _ => {},
-                    }
-                }
-                self.visit_type(&*borrow_type.ty, cx);
-            },
-            TyKind::Slice(ref ty) => {
-                self.visit_type(ty, cx);
-            },
-            _ => {},
-        }
+        let mut rsl =
+            RedundantStaticLifetime::new(CONST_STATIC_LIFETIME, "Constants have by default a `'static` lifetime");
+        rsl.visit_type(ty, cx)
     }
 }
 

diff --git a/clippy_lints/src/lib.rs b/clippy_lints/src/lib.rs
@@ -141,6 +141,7 @@ macro_rules! declare_clippy_lint {
 mod consts;
 #[macro_use]
 mod utils;
+mod redundant_static_lifetime;
 
 // begin lints modules, do not remove this comment, it’s used in `update_lints`
 pub mod approx_const;

diff --git a/clippy_lints/src/redundant_static_lifetime.rs b/clippy_lints/src/redundant_static_lifetime.rs
@@ -0,0 +1,57 @@
+use crate::utils::{snippet, span_lint_and_then};
+use rustc::lint::{EarlyContext, Lint};
+use rustc_errors::Applicability;
+use syntax::ast::*;
+
+pub struct RedundantStaticLifetime {
+    lint: &'static Lint,
+    reason: &'static str,
+}
+
+impl RedundantStaticLifetime {
+    pub fn new(lint: &'static Lint, reason: &'static str) -> Self {
+        Self { lint, reason }
+    }
+    // Recursively visit types
+    pub fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext<'_>) {
+        match ty.node {
+            // Be careful of nested structures (arrays and tuples)
+            TyKind::Array(ref ty, _) => {
+                self.visit_type(&*ty, cx);
+            },
+            TyKind::Tup(ref tup) => {
+                for tup_ty in tup {
+                    self.visit_type(&*tup_ty, cx);
+                }
+            },
+            // This is what we are looking for !
+            TyKind::Rptr(ref optional_lifetime, ref borrow_type) => {
+                // Match the 'static lifetime
+                if let Some(lifetime) = *optional_lifetime {
+                    match borrow_type.ty.node {
+                        TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) | TyKind::Tup(..) => {
+                            if lifetime.ident.name == syntax::symbol::kw::StaticLifetime {
+                                let snip = snippet(cx, borrow_type.ty.span, "<type>");
+                                let sugg = format!("&{}", snip);
+                                span_lint_and_then(cx, self.lint, lifetime.ident.span, self.reason, |db| {
+                                    db.span_suggestion(
+                                        ty.span,
+                                        "consider removing `'static`",
+                                        sugg,
+                                        Applicability::MachineApplicable, //snippet
+                                    );
+                                });
+                            }
+                        },
+                        _ => {},
+                    }
+                }
+                self.visit_type(&*borrow_type.ty, cx);
+            },
+            TyKind::Slice(ref ty) => {
+                self.visit_type(ty, cx);
+            },
+            _ => {},
+        }
+    }
+}