Lint binary regexes

Author: mcarton

src/regex.rs

@@ -9,7 +9,7 @@ use std::error::Error;
 use syntax::ast::{LitKind, NodeId};
 use syntax::codemap::{Span, BytePos};
 use syntax::parse::token::InternedString;
-use utils::{is_expn_of, match_path, match_type, paths, span_lint, span_help_and_lint};
+use utils::{is_expn_of, match_def_path, match_type, paths, span_lint, span_help_and_lint};
 
 /// **What it does:** This lint checks `Regex::new(_)` invocations for correct regex syntax.
 ///
@@ -96,12 +96,23 @@ impl LateLintPass for RegexPass {
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if_let_chain!{[
             let ExprCall(ref fun, ref args) = expr.node,
-            let ExprPath(_, ref path) = fun.node,
-            match_path(path, &paths::REGEX_NEW) && args.len() == 1
+            args.len() == 1
         ], {
+            let def_id = cx.tcx.def_map.borrow()[&fun.id].def_id();
+
+            let utf8 = if match_def_path(cx, def_id, &paths::REGEX_NEW) {
+                true
+            } else if match_def_path(cx, def_id, &paths::REGEX_BYTES_NEW) {
+                false
+            } else {
+                return;
+            };
+
+            let builder = regex_syntax::ExprBuilder::new().unicode(utf8);
+
             if let ExprLit(ref lit) = args[0].node {
                 if let LitKind::Str(ref r, _) = lit.node {
-                    match regex_syntax::Expr::parse(r) {
+                    match builder.parse(r) {
                         Ok(r) => {
                             if let Some(repl) = is_trivial_regex(&r) {
                                 span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,
@@ -119,7 +130,7 @@ impl LateLintPass for RegexPass {
                     }
                 }
             } else if let Some(r) = const_str(cx, &*args[0]) {
-                match regex_syntax::Expr::parse(&r) {
+                match builder.parse(&r) {
                     Ok(r) => {
                         if let Some(repl) = is_trivial_regex(&r) {
                             span_help_and_lint(cx, TRIVIAL_REGEX, args[0].span,

src/utils/paths.rs

@@ -46,7 +46,9 @@ 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_NEW: [&'static str; 3] = ["regex", "Regex", "new"];
+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 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

@@ -7,6 +7,7 @@
 extern crate regex;
 
 use regex::Regex;
+use regex::bytes::Regex as BRegex;
 
 const OPENING_PAREN : &'static str = "(";
 const NOT_A_REAL_REGEX : &'static str = "foobar";
@@ -22,6 +23,11 @@ fn syntax_error() {
     let some_regex = Regex::new(OPENING_PAREN);
     //~^ERROR: regex syntax error on position 0: unclosed
 
+    let binary_pipe_in_wrong_position = BRegex::new("|");
+    //~^ERROR: regex syntax error: empty alternate
+    let some_binary_regex = BRegex::new(OPENING_PAREN);
+    //~^ERROR: regex syntax error on position 0: unclosed
+
     let closing_paren = ")";
     let not_linted = Regex::new(closing_paren);
 }
@@ -64,12 +70,17 @@ fn trivial_regex() {
     //~^ERROR: trivial regex
     //~|HELP consider using `str::is_empty`
 
+    let binary_trivial_empty = BRegex::new("^$");
+    //~^ERROR: trivial regex
+    //~|HELP consider using `str::is_empty`
+
     // non-trivial regexes
     let non_trivial_dot = Regex::new("a.b");
     let non_trivial_eq = Regex::new("^foo|bar$");
     let non_trivial_starts_with = Regex::new("^foo|bar");
     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");
 }
 
 fn main() {