Support Regex::with_size_limit as well as new

Author: mcarton

src/regex.rs

@@ -96,52 +96,58 @@ impl LateLintPass for RegexPass {
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if_let_chain!{[
             let ExprCall(ref fun, ref args) = expr.node,
-            args.len() == 1
+            args.len() >= 1,
+            let Some(def) = cx.tcx.def_map.borrow().get(&fun.id)
         ], {
-            let def_id = cx.tcx.def_map.borrow()[&fun.id].def_id();
+            let (utf8_path, bytes_path, re_idx) = match args.len() {
+                1 => (paths::REGEX_NEW, paths::REGEX_BYTES_NEW, 0),
+                2 => (paths::REGEX_WSL, paths::REGEX_BYTES_WSL, 1),
+                _ => return,
+            };
 
-            let utf8 = if match_def_path(cx, def_id, &paths::REGEX_NEW) {
+            let def_id = def.def_id();
+            let utf8 = if match_def_path(cx, def_id, utf8_path) {
                 true
-            } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_NEW) {
+            } else if match_def_path(cx, def_id, bytes_path) {
                 false
             } else {
                 return;
             };
 
             let builder = regex_syntax::ExprBuilder::new().unicode(utf8);
 
-            if let ExprLit(ref lit) = args[0].node {
+            if let ExprLit(ref lit) = args[re_idx].node {
                 if let LitKind::Str(ref r, _) = lit.node {
                     match builder.parse(r) {
                         Ok(r) => {
                             if let Some(repl) = is_trivial_regex(&r) {
-                                span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,
+                                span_help_and_lint(cx, TRIVIAL_REGEX, args[re_idx].span,
                                                    "trivial regex",
                                                    &format!("consider using {}", repl));
                             }
                         }
                         Err(e) => {
                             span_lint(cx,
                                       INVALID_REGEX,
-                                      str_span(args[0].span, &r, e.position()),
+                                      str_span(args[re_idx].span, &r, e.position()),
                                       &format!("regex syntax error: {}",
                                                e.description()));
                         }
                     }
                 }
-            } else if let Some(r) = const_str(cx, &*args[0]) {
+            } else if let Some(r) = const_str(cx, &*args[re_idx]) {
                 match builder.parse(&r) {
                     Ok(r) => {
                         if let Some(repl) = is_trivial_regex(&r) {
-                            span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,
+                            span_help_and_lint(cx, TRIVIAL_REGEX, args[re_idx].span,
                                                "trivial regex",
                                                &format!("consider using {}", repl));
                         }
                     }
                     Err(e) => {
                         span_lint(cx,
                                   INVALID_REGEX,
-                                  args[0].span,
+                                  args[re_idx].span,
                                   &format!("regex syntax error on position {}: {}",
                                            e.position(),
                                            e.description()));

src/utils/paths.rs

@@ -46,9 +46,11 @@ pub const RANGE_TO_INCLUSIVE: [&'static str; 3] = ["core", "ops", "RangeToInclus
 pub const RANGE_TO_INCLUSIVE_STD: [&'static str; 3] = ["std", "ops", "RangeToInclusive"];
 pub const RANGE_TO_STD: [&'static str; 3] = ["std", "ops", "RangeTo"];
 pub const REGEX: [&'static str; 3] = ["regex", "re_unicode", "Regex"];
-pub const REGEX_BYTES: [&'static str; 3] = ["regex", "re_bytes", "Regex"];
-pub const REGEX_BYTES_NEW: [&'static str; 4] = ["regex", "re_bytes", "Regex", "new"];
-pub const REGEX_NEW: [&'static str; 4] = ["regex", "re_unicode", "Regex", "new"];
+pub const REGEX_BYTES: &'static [&'static str] = &["regex", "re_bytes", "Regex"];
+pub const REGEX_BYTES_NEW: &'static [&'static str] = &["regex", "re_bytes", "Regex", "new"];
+pub const REGEX_BYTES_WSL: &'static [&'static str] = &["regex", "re_bytes", "Regex", "with_size_limit"];
+pub const REGEX_NEW: &'static [&'static str] = &["regex", "re_unicode", "Regex", "new"];
+pub const REGEX_WSL: &'static [&'static str] = &["regex", "re_unicode", "Regex", "with_size_limit"];
 pub const RESULT: [&'static str; 3] = ["core", "result", "Result"];
 pub const STRING: [&'static str; 3] = ["collections", "string", "String"];
 pub const TRANSMUTE: [&'static str; 4] = ["core", "intrinsics", "", "transmute"];

tests/compile-fail/regex.rs

@@ -15,8 +15,12 @@ const NOT_A_REAL_REGEX : &'static str = "foobar";
 fn syntax_error() {
     let pipe_in_wrong_position = Regex::new("|");
     //~^ERROR: regex syntax error: empty alternate
+    let pipe_in_wrong_position2 = Regex::with_size_limit(42, "|");
+    //~^ERROR: regex syntax error: empty alternate
     let wrong_char_ranice = Regex::new("[z-a]");
     //~^ERROR: regex syntax error: invalid character class range
+    let wrong_char_ranice2 = Regex::with_size_limit(42, "[z-a]");
+    //~^ERROR: regex syntax error: invalid character class range
     let some_unicode = Regex::new("[é-è]");
     //~^ERROR: regex syntax error: invalid character class range
 
@@ -25,18 +29,28 @@ fn syntax_error() {
 
     let binary_pipe_in_wrong_position = BRegex::new("|");
     //~^ERROR: regex syntax error: empty alternate
+    let binary_pipe_in_wrong_position = BRegex::with_size_limit(42, "|");
+    //~^ERROR: regex syntax error: empty alternate
+
     let some_binary_regex = BRegex::new(OPENING_PAREN);
     //~^ERROR: regex syntax error on position 0: unclosed
+    let some_binary_regex2 = BRegex::with_size_limit(42, OPENING_PAREN);
+    //~^ERROR: regex syntax error on position 0: unclosed
 
     let closing_paren = ")";
     let not_linted = Regex::new(closing_paren);
+    let not_linted2 = Regex::with_size_limit(42, closing_paren);
 }
 
 fn trivial_regex() {
     let trivial_eq = Regex::new("^foobar$");
     //~^ERROR: trivial regex
     //~|HELP consider using `==` on `str`s
 
+    let trivial_eq2 = Regex::with_size_limit(42, "^foobar$");
+    //~^ERROR: trivial regex
+    //~|HELP consider using `==` on `str`s
+
     let trivial_starts_with = Regex::new("^foobar");
     //~^ERROR: trivial regex
     //~|HELP consider using `str::starts_with`
@@ -73,6 +87,9 @@ fn trivial_regex() {
     let binary_trivial_empty = BRegex::new("^$");
     //~^ERROR: trivial regex
     //~|HELP consider using `str::is_empty`
+    let binary_trivial_empty2 = BRegex::with_size_limit(42, "^$");
+    //~^ERROR: trivial regex
+    //~|HELP consider using `str::is_empty`
 
     // non-trivial regexes
     let non_trivial_dot = Regex::new("a.b");
@@ -81,6 +98,7 @@ fn trivial_regex() {
     let non_trivial_ends_with = Regex::new("^foo|bar");
     let non_trivial_ends_with = Regex::new("foo|bar");
     let non_trivial_binary = BRegex::new("foo|bar");
+    let non_trivial_binary2 = BRegex::with_size_limit(42, "foo|bar");
 }
 
 fn main() {