progress

Author: BurntSushi

Cargo.lock

@@ -48,6 +48,11 @@ members = [
   "crates/ignore",
 ]
 
+[patch.crates-io]
+regex = { path = "/home/andrew/rust/regex" }
+regex-automata = { path = "/home/andrew/rust/regex/regex-automata" }
+regex-syntax = { path = "/home/andrew/rust/regex/regex-syntax" }
+
 [dependencies]
 bstr = "1.6.0"
 grep = { version = "0.2.12", path = "crates/grep" }

Cargo.toml

@@ -26,12 +26,12 @@ log = { version = "0.4.20", optional = true }
 serde = { version = "1.0.188", optional = true }
 
 [dependencies.regex-syntax]
-version = "0.7.5"
+version = "0.8.0"
 default-features = false
 features = ["std"]
 
 [dependencies.regex-automata]
-version = "0.3.8"
+version = "0.4.0"
 default-features = false
 features = ["std", "perf", "syntax", "meta", "nfa", "hybrid"]
 

crates/globset/Cargo.toml

@@ -27,7 +27,7 @@ same-file = "1.0.6"
 walkdir = "2.4.0"
 
 [dependencies.regex-automata]
-version = "0.3.8"
+version = "0.4.0"
 default-features = false
 features = ["std", "perf", "syntax", "meta", "nfa", "hybrid", "dfa-onepass"]
 

crates/ignore/Cargo.toml

@@ -17,5 +17,5 @@ edition = "2021"
 bstr = "1.6.2"
 grep-matcher = { version = "0.1.6", path = "../matcher" }
 log = "0.4.20"
-regex-automata = { version = "0.3.8" }
-regex-syntax = "0.7.5"
+regex-automata = { version = "0.4.0" }
+regex-syntax = "0.8.0"

crates/regex/Cargo.toml

@@ -62,12 +62,12 @@ impl AstAnalysis {
             Ast::Flags(_)
             | Ast::Dot(_)
             | Ast::Assertion(_)
-            | Ast::Class(ast::Class::Unicode(_))
-            | Ast::Class(ast::Class::Perl(_)) => {}
+            | Ast::ClassUnicode(_)
+            | Ast::ClassPerl(_) => {}
             Ast::Literal(ref x) => {
                 self.from_ast_literal(x);
             }
-            Ast::Class(ast::Class::Bracketed(ref x)) => {
+            Ast::ClassBracketed(ref x) => {
                 self.from_ast_class_set(&x.kind);
             }
             Ast::Repetition(ref x) => {

crates/regex/src/ast.rs

@@ -3,7 +3,7 @@ use {
     regex_automata::meta::Regex,
     regex_syntax::{
         ast,
-        hir::{self, Hir, HirKind},
+        hir::{self, Hir},
     },
 };
 
@@ -296,35 +296,6 @@ impl ConfiguredHIR {
         }
     }
 
-    /// Turns this configured HIR into one that only matches when both sides of
-    /// the match correspond to a word boundary.
-    ///
-    /// Note that the HIR returned is like turning `pat` into
-    /// `(?m:^|\W)(pat)(?m:$|\W)`. That is, the true match is at capture group
-    /// `1` and not `0`.
-    pub(crate) fn into_word(self) -> Result<ConfiguredHIR, Error> {
-        // In theory building the HIR for \W should never fail, but there are
-        // likely some pathological cases (particularly with respect to certain
-        // values of limits) where it could in theory fail.
-        let non_word = {
-            let mut config = self.config.clone();
-            config.fixed_strings = false;
-            ConfiguredHIR::new(config, &[r"\W"])?
-        };
-        let line_anchor_start = Hir::look(self.line_anchor_start());
-        let line_anchor_end = Hir::look(self.line_anchor_end());
-        let hir = Hir::concat(vec![
-            Hir::alternation(vec![line_anchor_start, non_word.hir.clone()]),
-            Hir::capture(hir::Capture {
-                index: 1,
-                name: None,
-                sub: Box::new(renumber_capture_indices(self.hir)?),
-            }),
-            Hir::alternation(vec![non_word.hir, line_anchor_end]),
-        ]);
-        Ok(ConfiguredHIR { config: self.config, hir })
-    }
-
     /// Turns this configured HIR into an equivalent one, but where it must
     /// match at the start and end of a line.
     pub(crate) fn into_whole_line(self) -> ConfiguredHIR {
@@ -336,12 +307,20 @@ impl ConfiguredHIR {
     }
 
     /// Turns this configured HIR into an equivalent one, but where it must
-    /// match at the start and end of the haystack.
-    pub(crate) fn into_anchored(self) -> ConfiguredHIR {
+    /// match at word boundaries.
+    pub(crate) fn into_word(self) -> ConfiguredHIR {
         let hir = Hir::concat(vec![
-            Hir::look(hir::Look::Start),
+            Hir::look(if self.config.unicode {
+                hir::Look::WordStartHalfUnicode
+            } else {
+                hir::Look::WordStartHalfAscii
+            }),
             self.hir,
-            Hir::look(hir::Look::End),
+            Hir::look(if self.config.unicode {
+                hir::Look::WordEndHalfUnicode
+            } else {
+                hir::Look::WordEndHalfAscii
+            }),
         ]);
         ConfiguredHIR { config: self.config, hir }
     }
@@ -365,50 +344,6 @@ impl ConfiguredHIR {
     }
 }
 
-/// This increments the index of every capture group in the given hir by 1. If
-/// any increment results in an overflow, then an error is returned.
-fn renumber_capture_indices(hir: Hir) -> Result<Hir, Error> {
-    Ok(match hir.into_kind() {
-        HirKind::Empty => Hir::empty(),
-        HirKind::Literal(hir::Literal(lit)) => Hir::literal(lit),
-        HirKind::Class(cls) => Hir::class(cls),
-        HirKind::Look(x) => Hir::look(x),
-        HirKind::Repetition(mut x) => {
-            x.sub = Box::new(renumber_capture_indices(*x.sub)?);
-            Hir::repetition(x)
-        }
-        HirKind::Capture(mut cap) => {
-            cap.index = match cap.index.checked_add(1) {
-                Some(index) => index,
-                None => {
-                    // This error message kind of sucks, but it's probably
-                    // impossible for it to happen. The only way a capture
-                    // index can overflow addition is if the regex is huge
-                    // (or something else has gone horribly wrong).
-                    let msg = "could not renumber capture index, too big";
-                    return Err(Error::any(msg));
-                }
-            };
-            cap.sub = Box::new(renumber_capture_indices(*cap.sub)?);
-            Hir::capture(cap)
-        }
-        HirKind::Concat(subs) => {
-            let subs = subs
-                .into_iter()
-                .map(|sub| renumber_capture_indices(sub))
-                .collect::<Result<Vec<Hir>, Error>>()?;
-            Hir::concat(subs)
-        }
-        HirKind::Alternation(subs) => {
-            let subs = subs
-                .into_iter()
-                .map(|sub| renumber_capture_indices(sub))
-                .collect::<Result<Vec<Hir>, Error>>()?;
-            Hir::alternation(subs)
-        }
-    })
-}
-
 /// Returns true if the given literal string contains any byte from the line
 /// terminator given.
 fn has_line_terminator(lineterm: LineTerminator, literal: &str) -> bool {

crates/regex/src/config.rs

@@ -30,10 +30,6 @@ impl Error {
         Error { kind: ErrorKind::Regex(err.to_string()) }
     }
 
-    pub(crate) fn any<E: ToString>(msg: E) -> Error {
-        Error { kind: ErrorKind::Regex(msg.to_string()) }
-    }
-
     /// Return the kind of this error.
     pub fn kind(&self) -> &ErrorKind {
         &self.kind

crates/regex/src/error.rs

@@ -15,4 +15,3 @@ mod literal;
 mod matcher;
 mod non_matching;
 mod strip;
-mod word;