Merge branch 'macro-use' into HEAD

[rust.git] / clippy_lints / src / const_static_lifetime.rs

diff --git a/clippy_lints/src/const_static_lifetime.rs b/clippy_lints/src/const_static_lifetime.rs
index 4801f788856b8ed87fe15f6debfdb3acb3e52632..8bb209a649025d8366e5079faa4d59642e72d79b 100644 (file)
--- a/clippy_lints/src/const_static_lifetime.rs
+++ b/clippy_lints/src/const_static_lifetime.rs
@@ -1,6 +1,7 @@
-use syntax::ast::{Item, ItemKind, TyKind, Ty};
-use rustc::lint::{LintPass, EarlyLintPass, LintArray, EarlyContext};
-use utils::{span_lint_and_then, in_macro};
+use syntax::ast::*;
+use rustc::lint::{EarlyContext, EarlyLintPass, LintArray, LintPass};
+use rustc::{declare_lint, lint_array};
+use crate::utils::{in_macro, snippet, span_lint_and_then};
 
 /// **What it does:** Checks for constants with an explicit `'static` lifetime.
 ///
@@ -18,10 +19,9 @@
 /// ```rust
 ///  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
 /// ```
-
-declare_lint! {
-    pub CONST_STATIC_LIFETIME, 
-    Warn,
+declare_clippy_lint! {
+    pub CONST_STATIC_LIFETIME,
+    style,
     "Using explicit `'static` lifetime for constants when elision rules would allow omitting them."
 }
 
@@ -37,29 +37,35 @@ impl StaticConst {
     // Recursively visit types
     fn visit_type(&mut self, ty: &Ty, cx: &EarlyContext) {
         match ty.node {
-            // Be carefull of nested structures (arrays and tuples)
+            // 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);
-                }
+            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 {
-                    if let TyKind::Path(_, _) = borrow_type.ty.node {
-                        // Verify that the path is a str
-                        if lifetime.ident.name == "'static" {
-                            let mut sug: String = String::new();
-                            span_lint_and_then(cx,
-                                               CONST_STATIC_LIFETIME,
-                                               lifetime.span,
-                                               "Constants have by default a `'static` lifetime",
-                                               |db| {db.span_suggestion(lifetime.span,"consider removing `'static`",sug);});
+                    match borrow_type.ty.node {
+                        TyKind::Path(..) | TyKind::Slice(..) | TyKind::Array(..) |
+                        TyKind::Tup(..) => {
+                            if lifetime.ident.name == "'static" {
+                                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);
+                                    },
+                                );
+                            }
                         }
+                        _ => {}
                     }
                 }
                 self.visit_type(&*borrow_type.ty, cx);
@@ -81,4 +87,6 @@ fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
             }
         }
     }
+
+    // Don't check associated consts because `'static` cannot be elided on those (issue #2438)
 }