Lint about trivial regexes

src/lib.rs

@@ -257,6 +257,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
         ranges::RANGE_STEP_BY_ZERO,
         ranges::RANGE_ZIP_WITH_LEN,
         regex::INVALID_REGEX,
+        regex::TRIVIAL_REGEX,
         returns::LET_AND_RETURN,
         returns::NEEDLESS_RETURN,
         strings::STRING_LIT_AS_BYTES,

src/regex.rs

@@ -8,7 +8,7 @@ use rustc::middle::const_eval::{eval_const_expr_partial, ConstVal};
 use rustc::middle::const_eval::EvalHint::ExprTypeChecked;
 use rustc::lint::*;
 
-use utils::{match_path, REGEX_NEW_PATH, span_lint};
+use utils::{match_path, REGEX_NEW_PATH, span_lint, span_help_and_lint};
 
 /// **What it does:** This lint checks `Regex::new(_)` invocations for correct regex syntax. It is `deny` by default.
 ///
@@ -23,12 +23,26 @@ declare_lint! {
     "finds invalid regular expressions in `Regex::new(_)` invocations"
 }
 
+/// **What it does:** This lint checks for `Regex::new(_)` invocations with trivial regex.
+///
+/// **Why is this bad?** This can likely be replaced by `==` or `str::starts_with`,
+/// `str::ends_with` or `std::contains` or other `str` methods.
+///
+/// **Known problems:** None.
+///
+/// **Example:** `Regex::new("^foobar")`
+declare_lint! {
+    pub TRIVIAL_REGEX,
+    Warn,
+    "finds trivial regular expressions in `Regex::new(_)` invocations"
+}
+
 #[derive(Copy,Clone)]
 pub struct RegexPass;
 
 impl LintPass for RegexPass {
     fn get_lints(&self) -> LintArray {
-        lint_array!(INVALID_REGEX)
+        lint_array!(INVALID_REGEX, TRIVIAL_REGEX)
     }
 }
 
@@ -48,19 +62,26 @@ impl LateLintPass for RegexPass {
                                   &format!("regex syntax error: {}",
                                            e.description()));
                     }
+                    else if let Some(repl) = is_trivial_regex(r) {
+                        span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,
+                                           &"trivial regex",
+                                           &format!("consider using {}", repl));
+                    }
                 }
-            } else {
-                if_let_chain!{[
-                    let Some(r) = const_str(cx, &*args[0]),
-                    let Err(e) = regex_syntax::Expr::parse(&r)
-                ], {
+            } else if let Some(r) = const_str(cx, &*args[0]) {
+                if let Err(e) = regex_syntax::Expr::parse(&r) {
                     span_lint(cx,
                               INVALID_REGEX,
                               args[0].span,
                               &format!("regex syntax error on position {}: {}",
                                        e.position(),
                                        e.description()));
-                }}
+                }
+                else if let Some(repl) = is_trivial_regex(&r) {
+                    span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,
+                                       &"trivial regex",
+                                       &format!("{}", repl));
+                }
             }
         }}
     }
@@ -81,3 +102,26 @@ fn const_str(cx: &LateContext, e: &Expr) -> Option<InternedString> {
         _ => None
     }
 }
+
+fn is_trivial_regex(s: &str) -> Option<&'static str> {
+    // some unlikely but valid corner cases
+    match s {
+        "" | "^" | "$" => return Some("the regex is unlikely to be useful as it is"),
+        "^$" => return Some("consider using `str::is_empty`"),
+        _ => (),
+    }
+
+    let (start, end, repl) = match (s.starts_with('^'), s.ends_with('$')) {
+        (true, true) => (1, s.len()-1, "consider using `==` on `str`s"),
+        (false, true) => (0, s.len()-1, "consider using `str::ends_with`"),
+        (true, false) => (1, s.len(), "consider using `str::starts_with`"),
+        (false, false) => (0, s.len(), "consider using `str::contains`"),
+    };
+
+    if !s.chars().take(end).skip(start).any(regex_syntax::is_punct) {
+        Some(repl)
+    }
+    else {
+        None
+    }
+}