src/regex.rs

   1 use regex_syntax;
   2 use rustc::hir::*;
   3 use rustc::lint::*;
   4 use rustc::middle::const_val::ConstVal;
   5 use rustc_const_eval::EvalHint::ExprTypeChecked;
   6 use rustc_const_eval::eval_const_expr_partial;
   7 use std::collections::HashSet;
   8 use std::error::Error;
   9 use syntax::ast::{LitKind, NodeId};
  10 use syntax::codemap::{Span, BytePos};
  11 use syntax::parse::token::InternedString;
  12 use utils::{is_expn_of, match_def_path, match_type, paths, span_lint, span_help_and_lint};
  13
  14 /// **What it does:** This lint checks `Regex::new(_)` invocations for correct regex syntax.
  15 ///
  16 /// **Why is this bad?** This will lead to a runtime panic.
  17 ///
  18 /// **Known problems:** None.
  19 ///
  20 /// **Example:** `Regex::new("|")`
  21 declare_lint! {
  22     pub INVALID_REGEX,
  23     Deny,
  24     "finds invalid regular expressions in `Regex::new(_)` invocations"
  25 }
  26
  27 /// **What it does:** This lint checks for `Regex::new(_)` invocations with trivial regex.
  28 ///
  29 /// **Why is this bad?** This can likely be replaced by `==` or `str::starts_with`,
  30 /// `str::ends_with` or `std::contains` or other `str` methods.
  31 ///
  32 /// **Known problems:** None.
  33 ///
  34 /// **Example:** `Regex::new("^foobar")`
  35 declare_lint! {
  36     pub TRIVIAL_REGEX,
  37     Warn,
  38     "finds trivial regular expressions in `Regex::new(_)` invocations"
  39 }
  40
  41 /// **What it does:** This lint checks for usage of `regex!(_)` which as of now is usually slower than `Regex::new(_)` unless called in a loop (which is a bad idea anyway).
  42 ///
  43 /// **Why is this bad?** Performance, at least for now. The macro version is likely to catch up long-term, but for now the dynamic version is faster.
  44 ///
  45 /// **Known problems:** None
  46 ///
  47 /// **Example:** `regex!("foo|bar")`
  48 declare_lint! {
  49     pub REGEX_MACRO,
  50     Warn,
  51     "finds use of `regex!(_)`, suggests `Regex::new(_)` instead"
  52 }
  53
  54 #[derive(Clone, Default)]
  55 pub struct RegexPass {
  56     spans: HashSet<Span>,
  57     last: Option<NodeId>,
  58 }
  59
  60 impl LintPass for RegexPass {
  61     fn get_lints(&self) -> LintArray {
  62         lint_array!(INVALID_REGEX, REGEX_MACRO, TRIVIAL_REGEX)
  63     }
  64 }
  65
  66 impl LateLintPass for RegexPass {
  67     fn check_crate(&mut self, _: &LateContext, _: &Crate) {
  68         self.spans.clear();
  69     }
  70
  71     fn check_block(&mut self, cx: &LateContext, block: &Block) {
  72         if_let_chain!{[
  73             self.last.is_none(),
  74             let Some(ref expr) = block.expr,
  75             match_type(cx, cx.tcx.expr_ty(expr), &paths::REGEX),
  76             let Some(span) = is_expn_of(cx, expr.span, "regex"),
  77         ], {
  78             if !self.spans.contains(&span) {
  79                 span_lint(cx,
  80                           REGEX_MACRO,
  81                           span,
  82                           "`regex!(_)` found. \
  83                           Please use `Regex::new(_)`, which is faster for now.");
  84                 self.spans.insert(span);
  85             }
  86             self.last = Some(block.id);
  87         }}
  88     }
  89
  90     fn check_block_post(&mut self, _: &LateContext, block: &Block) {
  91         if self.last.map_or(false, |id| block.id == id) {
  92             self.last = None;
  93         }
  94     }
  95
  96     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
  97         if_let_chain!{[
  98             let ExprCall(ref fun, ref args) = expr.node,
  99             args.len() == 1,
 100             let Some(def) = cx.tcx.def_map.borrow().get(&fun.id),
 101         ], {
 102             let def_id = def.def_id();
 103             if match_def_path(cx, def_id, &paths::REGEX_NEW) {
 104                 check_regex(cx, &args[0], true);
 105             } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_NEW) {
 106                 check_regex(cx, &args[0], false);
 107             } else if match_def_path(cx, def_id, &paths::REGEX_BUILDER_NEW) {
 108                 check_regex(cx, &args[0], true);
 109             } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_BUILDER_NEW) {
 110                 check_regex(cx, &args[0], false);
 111             } else if match_def_path(cx, def_id, &paths::REGEX_SET_NEW) {
 112                 check_set(cx, &args[0], true);
 113             } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_SET_NEW) {
 114                 check_set(cx, &args[0], false);
 115             }
 116         }}
 117     }
 118 }
 119
 120 #[allow(cast_possible_truncation)]
 121 fn str_span(base: Span, s: &str, c: usize) -> Span {
 122     let mut si = s.char_indices().skip(c);
 123
 124     match (si.next(), si.next())  {
 125         (Some((l, _)), Some((h, _))) => {
 126             Span {
 127                 lo: base.lo + BytePos(l as u32),
 128                 hi: base.lo + BytePos(h as u32),
 129                 ..base
 130             }
 131         }
 132         _ => base,
 133     }
 134 }
 135
 136 fn const_str(cx: &LateContext, e: &Expr) -> Option<InternedString> {
 137     match eval_const_expr_partial(cx.tcx, e, ExprTypeChecked, None) {
 138         Ok(ConstVal::Str(r)) => Some(r),
 139         _ => None,
 140     }
 141 }
 142
 143 fn is_trivial_regex(s: &regex_syntax::Expr) -> Option<&'static str> {
 144     use regex_syntax::Expr;
 145
 146     match *s {
 147         Expr::Empty | Expr::StartText | Expr::EndText => Some("the regex is unlikely to be useful as it is"),
 148         Expr::Literal { .. } => Some("consider using `str::contains`"),
 149         Expr::Concat(ref exprs) => {
 150             match exprs.len() {
 151                 2 => {
 152                     match (&exprs[0], &exprs[1]) {
 153                         (&Expr::StartText, &Expr::EndText) => Some("consider using `str::is_empty`"),
 154                         (&Expr::StartText, &Expr::Literal { .. }) => Some("consider using `str::starts_with`"),
 155                         (&Expr::Literal { .. }, &Expr::EndText) => Some("consider using `str::ends_with`"),
 156                         _ => None,
 157                     }
 158                 }
 159                 3 => {
 160                     if let (&Expr::StartText, &Expr::Literal {..}, &Expr::EndText) = (&exprs[0], &exprs[1], &exprs[2]) {
 161                         Some("consider using `==` on `str`s")
 162                     } else {
 163                         None
 164                     }
 165                 }
 166                 _ => None,
 167             }
 168         }
 169         _ => None,
 170     }
 171 }
 172
 173 fn check_set(cx: &LateContext, expr: &Expr, utf8: bool) {
 174     if_let_chain! {[
 175         let ExprAddrOf(_, ref expr) = expr.node,
 176         let ExprVec(ref exprs) = expr.node,
 177     ], {
 178         for expr in exprs {
 179             check_regex(cx, expr, utf8);
 180         }
 181     }}
 182 }
 183
 184 fn check_regex(cx: &LateContext, expr: &Expr, utf8: bool) {
 185     let builder = regex_syntax::ExprBuilder::new().unicode(utf8);
 186
 187     if let ExprLit(ref lit) = expr.node {
 188         if let LitKind::Str(ref r, _) = lit.node {
 189             match builder.parse(r) {
 190                 Ok(r) => {
 191                     if let Some(repl) = is_trivial_regex(&r) {
 192                         span_help_and_lint(cx, TRIVIAL_REGEX, expr.span,
 193                                            "trivial regex",
 194                                            &format!("consider using {}", repl));
 195                     }
 196                 }
 197                 Err(e) => {
 198                     span_lint(cx,
 199                               INVALID_REGEX,
 200                               str_span(expr.span, r, e.position()),
 201                               &format!("regex syntax error: {}",
 202                                        e.description()));
 203                 }
 204             }
 205         }
 206     } else if let Some(r) = const_str(cx, expr) {
 207         match builder.parse(&r) {
 208             Ok(r) => {
 209                 if let Some(repl) = is_trivial_regex(&r) {
 210                     span_help_and_lint(cx, TRIVIAL_REGEX, expr.span,
 211                                        "trivial regex",
 212                                        &format!("consider using {}", repl));
 213                 }
 214             }
 215             Err(e) => {
 216                 span_lint(cx,
 217                           INVALID_REGEX,
 218                           expr.span,
 219                           &format!("regex syntax error on position {}: {}",
 220                                    e.position(),
 221                                    e.description()));
 222             }
 223         }
 224     }
 225 }