New lint : "const with a static lifetime"

clippy_lints/src/approx_const.rs

@@ -33,22 +33,22 @@ declare_lint! {
 }
 
 // Tuples are of the form (constant, name, min_digits)
-const KNOWN_CONSTS: &'static [(f64, &'static str, usize)] = &[(f64::E, "E", 4),
-                                                              (f64::FRAC_1_PI, "FRAC_1_PI", 4),
-                                                              (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
-                                                              (f64::FRAC_2_PI, "FRAC_2_PI", 5),
-                                                              (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
-                                                              (f64::FRAC_PI_2, "FRAC_PI_2", 5),
-                                                              (f64::FRAC_PI_3, "FRAC_PI_3", 5),
-                                                              (f64::FRAC_PI_4, "FRAC_PI_4", 5),
-                                                              (f64::FRAC_PI_6, "FRAC_PI_6", 5),
-                                                              (f64::FRAC_PI_8, "FRAC_PI_8", 5),
-                                                              (f64::LN_10, "LN_10", 5),
-                                                              (f64::LN_2, "LN_2", 5),
-                                                              (f64::LOG10_E, "LOG10_E", 5),
-                                                              (f64::LOG2_E, "LOG2_E", 5),
-                                                              (f64::PI, "PI", 3),
-                                                              (f64::SQRT_2, "SQRT_2", 5)];
+const KNOWN_CONSTS: &[(f64, &str, usize)] = &[(f64::E, "E", 4),
+                                              (f64::FRAC_1_PI, "FRAC_1_PI", 4),
+                                              (f64::FRAC_1_SQRT_2, "FRAC_1_SQRT_2", 5),
+                                              (f64::FRAC_2_PI, "FRAC_2_PI", 5),
+                                              (f64::FRAC_2_SQRT_PI, "FRAC_2_SQRT_PI", 5),
+                                              (f64::FRAC_PI_2, "FRAC_PI_2", 5),
+                                              (f64::FRAC_PI_3, "FRAC_PI_3", 5),
+                                              (f64::FRAC_PI_4, "FRAC_PI_4", 5),
+                                              (f64::FRAC_PI_6, "FRAC_PI_6", 5),
+                                              (f64::FRAC_PI_8, "FRAC_PI_8", 5),
+                                              (f64::LN_10, "LN_10", 5),
+                                              (f64::LN_2, "LN_2", 5),
+                                              (f64::LOG10_E, "LOG10_E", 5),
+                                              (f64::LOG2_E, "LOG2_E", 5),
+                                              (f64::PI, "PI", 3),
+                                              (f64::SQRT_2, "SQRT_2", 5)];
 
 #[derive(Copy,Clone)]
 pub struct Pass;

clippy_lints/src/block_in_if_condition.rs

@@ -71,8 +71,8 @@ impl<'a, 'tcx: 'a> Visitor<'tcx> for ExVisitor<'a, 'tcx> {
     }
 }
 
-const BRACED_EXPR_MESSAGE: &'static str = "omit braces around single expression condition";
-const COMPLEX_BLOCK_MESSAGE: &'static str = "in an 'if' condition, avoid complex blocks or closures with blocks; \
+const BRACED_EXPR_MESSAGE: &str = "omit braces around single expression condition";
+const COMPLEX_BLOCK_MESSAGE: &str = "in an 'if' condition, avoid complex blocks or closures with blocks; \
                                              instead, move the block or closure higher and bind it with a 'let'";
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for BlockInIfCondition {

clippy_lints/src/const_static_lifetime.rs

@@ -0,0 +1,63 @@
+use syntax::ast::{Item, ItemKind, TyKind, ExprKind};
+use rustc::lint::{LintPass, EarlyLintPass, LintArray, EarlyContext};
+use utils::span_help_and_lint;
+
+/// **What it does:** Checks for constants with an explicit `'static` lifetime.
+///
+/// **Why is this bad?** Adding `'static` to every reference can create very complicated types.
+///
+/// **Known problems:** None.
+///
+/// **Example:**
+/// ```rust
+///  const FOO: &'static [(&'static str, &'static str, fn(&Bar) -> bool)] = &[..]
+/// ```
+/// This code can be rewritten as
+/// ```rust
+///  const FOO: &[(&str, &str, fn(&Bar) -> bool)] = &[...]
+/// ```
+
+declare_lint! {
+    pub CONST_STATIC_LIFETIME, 
+    Warn,
+    "Using explicit `'static` lifetime for constants when elision rules would allow omitting them."
+}
+
+pub struct StaticConst;
+
+impl LintPass for StaticConst {
+    fn get_lints(&self) -> LintArray {
+        lint_array!(CONST_STATIC_LIFETIME)
+    }
+}
+
+impl EarlyLintPass for StaticConst {
+    fn check_item(&mut self, cx: &EarlyContext, item: &Item) {
+        // Match only constants...
+        if let ItemKind::Const(ref var_type, ref expr) = item.node {
+            // ... which are actually variables, not declaration such as #![feature(clippy)] ...
+            // if let ExprKind::Lit(_) = expr.node {
+            // ... which are reference ...
+            if let TyKind::Rptr(ref optionnal_lifetime, _) = var_type.node {
+                // ... and have an explicit 'static lifetime.
+                if let Some(lifetime) = *optionnal_lifetime {
+
+                    println!("item : \n {:?} \n item.node : \n {:?}", item, item.node);
+                    println!("var_type : \n {:?} \n var_type.node : \n {:?}", var_type, var_type.node);
+                    println!("expr : \n {:?} \n expr.node : \n {:?}", expr, expr.node);
+                    println!("lifetime : {:?}", lifetime);
+
+
+                    if lifetime.ident.name == "'static" {
+                        span_help_and_lint(cx,
+                                           CONST_STATIC_LIFETIME,
+                                           lifetime.span,
+                                           "Constants have by default a `'static` lifetime",
+                                           "consider removing the `'static`");
+                    }
+                }
+                //  }
+            }
+        }
+    }
+}

clippy_lints/src/doc.rs

@@ -61,7 +61,7 @@ impl EarlyLintPass for Doc {
 #[allow(cast_possible_truncation)]
 pub fn strip_doc_comment_decoration((comment, span): (String, Span)) -> Vec<(String, Span)> {
     // one-line comments lose their prefix
-    const ONELINERS: &'static [&'static str] = &["///!", "///", "//!", "//"];
+    const ONELINERS: &[&str] = &["///!", "///", "//!", "//"];
     for prefix in ONELINERS {
         if comment.starts_with(*prefix) {
             return vec![(comment[prefix.len()..].to_owned(),

clippy_lints/src/lib.rs

@@ -72,6 +72,7 @@ pub mod blacklisted_name;
 pub mod block_in_if_condition;
 pub mod booleans;
 pub mod collapsible_if;
+pub mod const_static_lifetime;
 pub mod copies;
 pub mod cyclomatic_complexity;
 pub mod derive;
@@ -308,6 +309,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
     reg.register_late_lint_pass(box large_enum_variant::LargeEnumVariant::new(conf.enum_variant_size_threshold));
     reg.register_late_lint_pass(box should_assert_eq::ShouldAssertEq);
     reg.register_late_lint_pass(box needless_pass_by_value::NeedlessPassByValue);
+    reg.register_early_lint_pass(box const_static_lifetime::StaticConst);
 
     reg.register_lint_group("clippy_restrictions", vec![
         arithmetic::FLOAT_ARITHMETIC,
@@ -520,6 +522,7 @@ pub fn register_plugins(reg: &mut rustc_plugin::Registry) {
         unused_label::UNUSED_LABEL,
         vec::USELESS_VEC,
         zero_div_zero::ZERO_DIVIDED_BY_ZERO,
+        const_static_lifetime::CONST_STATIC_LIFETIME
     ]);
 }
 

clippy_lints/src/methods.rs

@@ -1277,7 +1277,7 @@ enum Convention {
 }
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
-const CONVENTIONS: [(Convention, &'static [SelfKind]); 6] = [
+const CONVENTIONS: [(Convention, &[SelfKind]); 6] = [
     (Convention::Eq("new"), &[SelfKind::No]),
     (Convention::StartsWith("as_"), &[SelfKind::Ref, SelfKind::RefMut]),
     (Convention::StartsWith("from_"), &[SelfKind::No]),
@@ -1287,7 +1287,7 @@ const CONVENTIONS: [(Convention, &'static [SelfKind]); 6] = [
 ];
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
-const TRAIT_METHODS: [(&'static str, usize, SelfKind, OutType, &'static str); 30] = [
+const TRAIT_METHODS: [(&str, usize, SelfKind, OutType, &str); 30] = [
     ("add", 2, SelfKind::Value, OutType::Any, "std::ops::Add"),
     ("as_mut", 1, SelfKind::RefMut, OutType::Ref, "std::convert::AsMut"),
     ("as_ref", 1, SelfKind::Ref, OutType::Ref, "std::convert::AsRef"),
@@ -1321,7 +1321,7 @@ const TRAIT_METHODS: [(&'static str, usize, SelfKind, OutType, &'static str); 30
 ];
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
-const PATTERN_METHODS: [(&'static str, usize); 17] = [
+const PATTERN_METHODS: [(&str, usize); 17] = [
     ("contains", 1),
     ("starts_with", 1),
     ("ends_with", 1),

clippy_lints/src/needless_continue.rs

@@ -252,15 +252,15 @@ struct LintData<'a> {
     block_stmts: &'a [ast::Stmt],
 }
 
-const MSG_REDUNDANT_ELSE_BLOCK: &'static str = "This else block is redundant.\n";
+const MSG_REDUNDANT_ELSE_BLOCK: &str = "This else block is redundant.\n";
 
-const MSG_ELSE_BLOCK_NOT_NEEDED: &'static str = "There is no need for an explicit `else` block for this `if` \
+const MSG_ELSE_BLOCK_NOT_NEEDED: &str = "There is no need for an explicit `else` block for this `if` \
                                                  expression\n";
 
-const DROP_ELSE_BLOCK_AND_MERGE_MSG: &'static str = "Consider dropping the else clause and merging the code that \
+const DROP_ELSE_BLOCK_AND_MERGE_MSG: &str = "Consider dropping the else clause and merging the code that \
                                                      follows (in the loop) with the if block, like so:\n";
 
-const DROP_ELSE_BLOCK_MSG: &'static str = "Consider dropping the else clause, and moving out the code in the else \
+const DROP_ELSE_BLOCK_MSG: &str = "Consider dropping the else clause, and moving out the code in the else \
                                            block, like so:\n";
 
 

clippy_lints/src/non_expressive_names.rs

@@ -69,7 +69,7 @@ struct SimilarNamesLocalVisitor<'a, 'tcx: 'a> {
 // this list contains lists of names that are allowed to be similar
 // the assumption is that no name is ever contained in multiple lists.
 #[cfg_attr(rustfmt, rustfmt_skip)]
-const WHITELIST: &'static [&'static [&'static str]] = &[
+const WHITELIST: &[&[&str]] = &[
     &["parsed", "parser"],
     &["lhs", "rhs"],
     &["tx", "rx"],

clippy_tests/examples/const_static_lifetime.rs

@@ -0,0 +1,13 @@
+#![feature(plugin)]
+#![plugin(clippy)]
+
+const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removing 'static.
+
+const VAR_TWO: &str = "Test constant #2"; // This line should not raise a warning.
+
+fn main() {
+
+    println!("{}", VAR_ONE);
+    println!("{}", VAR_TWO);
+
+}

clippy_tests/examples/const_static_lifetime.stderr

@@ -0,0 +1,14 @@
+error: Constants have by default a `'static` lifetime
+ --> const_static_lifetime.rs:4:17
+  |
+4 | const VAR_ONE: &'static str = "Test constant #1"; // ERROR Consider removing 'static.
+  |                 ^^^^^^^
+  |
+  = note: `-D const-static-lifetime` implied by `-D warnings`
+  = help: consider removing the `'static`
+
+error: aborting due to previous error(s)
+
+error: Could not compile `clippy_tests`.
+
+To learn more, run the command again with --verbose.