feat: zero-width patterns

harper-core/src/patterns/all.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::Pattern;
@@ -24,14 +22,14 @@ impl All {
 }
 
 impl Pattern for All {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         let mut max = 0;
 
         for pattern in &self.children {
             let len = pattern.matches(tokens, source)?;
-            max = max.max(len.get());
+            max = max.max(len);
         }
 
-        NonZeroUsize::new(max)
+        Some(max)
     }
 }

harper-core/src/patterns/any_pattern.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::Pattern;
@@ -8,7 +6,7 @@ use super::Pattern;
 pub struct AnyPattern;
 
 impl Pattern for AnyPattern {
-    fn matches(&self, tokens: &[Token], _source: &[char]) -> Option<NonZeroUsize> {
-        NonZeroUsize::new(if tokens.is_empty() { 0 } else { 1 })
+    fn matches(&self, tokens: &[Token], _source: &[char]) -> Option<usize> {
+        if tokens.is_empty() { None } else { Some(1) }
     }
 }

harper-core/src/patterns/either_pattern.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::Pattern;
@@ -21,17 +19,23 @@ impl EitherPattern {
 }
 
 impl Pattern for EitherPattern {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
-        let mut longest = 0;
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
+        let mut longest = None;
 
         for pattern in self.patterns.iter() {
-            let match_len = pattern.matches(tokens, source).map_or(0, NonZeroUsize::get);
-
-            if match_len > longest {
-                longest = match_len
+            let Some(match_len) = pattern.matches(tokens, source) else {
+                continue;
+            };
+
+            if let Some(longest_len) = longest {
+                if match_len > longest_len {
+                    longest = Some(match_len);
+                }
+            } else {
+                longest = Some(match_len);
             }
         }
 
-        NonZeroUsize::new(longest)
+        longest
     }
 }

harper-core/src/patterns/exact_phrase.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::{Document, Token, TokenKind};
 
 use super::{Pattern, SequencePattern, Word};
@@ -46,7 +44,7 @@ impl ExactPhrase {
 }
 
 impl Pattern for ExactPhrase {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         self.inner.matches(tokens, source)
     }
 }

harper-core/src/patterns/implies_quantity.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::{Token, TokenKind};
 
 use super::Pattern;
@@ -38,12 +36,12 @@ impl ImpliesQuantity {
 }
 
 impl Pattern for ImpliesQuantity {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
-        NonZeroUsize::new(if Self::implies_plurality(tokens, source).is_some() {
-            1
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
+        if Self::implies_plurality(tokens, source).is_some() {
+            Some(1)
         } else {
-            0
-        })
+            None
+        }
     }
 }
 

harper-core/src/patterns/indefinite_article.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::{Pattern, WordSet};
@@ -17,7 +15,7 @@ impl Default for IndefiniteArticle {
 }
 
 impl Pattern for IndefiniteArticle {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         self.inner.matches(tokens, source)
     }
 }

harper-core/src/patterns/inflection_of_be.rs

@@ -1,5 +1,3 @@
-use std::num::NonZero;
-
 use super::Pattern;
 use crate::Token;
 use crate::patterns::WordSet;
@@ -26,7 +24,7 @@ impl InflectionOfBe {
 }
 
 impl Pattern for InflectionOfBe {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZero<usize>> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         self.inner.matches(tokens, source)
     }
 }

harper-core/src/patterns/invert.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::Pattern;
@@ -18,11 +16,11 @@ impl Invert {
 }
 
 impl Pattern for Invert {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
-        NonZeroUsize::new(if self.inner.matches(tokens, source).is_some() {
-            0
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
+        if self.inner.matches(tokens, source).is_some() {
+            None
         } else {
-            1
-        })
+            Some(1)
+        }
     }
 }

harper-core/src/patterns/mod.rs

@@ -5,8 +5,6 @@
 //!
 //! See the page about [`SequencePattern`] for a concrete example of their use.
 
-use std::num::NonZeroUsize;
-
 use crate::{Document, Span, Token};
 
 mod all;
@@ -57,15 +55,15 @@ pub trait Pattern {
     /// Check if the pattern matches at the start of the given token slice.
     ///
     /// Returns the length of the match if successful, or `None` if not.
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize>;
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize>;
 }
 #[cfg(feature = "concurrent")]
 #[blanket(derive(Arc))]
 pub trait Pattern: Send + Sync {
     /// Check if the pattern matches at the start of the given token slice.
     ///
     /// Returns the length of the match if successful, or `None` if not.
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize>;
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize>;
 }
 
 pub trait PatternExt {
@@ -81,6 +79,9 @@ impl<P> PatternExt for P
 where
     P: Pattern + ?Sized,
 {
+    fn find_all_matches(&self, tokens: &[Token], source: &[char]) -> Vec<Span> {
+        self.iter_matches(tokens, source).collect()
+    }
     fn iter_matches(&self, tokens: &[Token], source: &[char]) -> impl Iterator<Item = Span> {
         MatchIter::new(self, tokens, source)
     }
@@ -117,8 +118,8 @@ where
                 .pattern
                 .matches(&self.tokens[self.index..], self.source)
             {
-                let span = Span::new_with_len(self.index, len.get());
-                self.index += len.get();
+                let span = Span::new_with_len(self.index, len);
+                self.index += len.max(1);
                 return Some(span);
             } else {
                 self.index += 1;
@@ -148,8 +149,12 @@ where
     F: Fn(&Token, &[char]) -> bool,
     F: Send + Sync,
 {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
-        NonZeroUsize::new(if self(tokens.first()?, source) { 1 } else { 0 })
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
+        if self(tokens.first()?, source) {
+            Some(1)
+        } else {
+            None
+        }
     }
 }
 
@@ -159,7 +164,11 @@ where
     F: Fn(&Token, &[char]) -> bool,
 {
     fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
-        NonZeroUsize::new(if self(tokens.first()?, source) { 1 } else { 0 })
+        if self(tokens.first()?, source) {
+            Some(1)
+        } else {
+            None
+        }
     }
 }
 

harper-core/src/patterns/naive_pattern_group.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use super::Pattern;
 use crate::Token;
 
@@ -17,7 +15,7 @@ impl NaivePatternGroup {
 }
 
 impl Pattern for NaivePatternGroup {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         self.patterns
             .iter()
             .filter_map(|p| p.matches(tokens, source))

harper-core/src/patterns/nominal_phrase.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::Token;
 
 use super::Pattern;
@@ -8,7 +6,7 @@ use super::Pattern;
 pub struct NominalPhrase;
 
 impl Pattern for NominalPhrase {
-    fn matches(&self, tokens: &[Token], _source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], _source: &[char]) -> Option<usize> {
         let mut cursor = 0;
 
         loop {
@@ -26,7 +24,7 @@ impl Pattern for NominalPhrase {
             }
 
             if tok.kind.is_nominal() {
-                return NonZeroUsize::new(cursor + 1);
+                return Some(cursor + 1);
             }
 
             return None;

harper-core/src/patterns/pattern_map.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use crate::LSend;
 use crate::Token;
 
@@ -69,7 +67,7 @@ impl<T> Pattern for PatternMap<T>
 where
     T: LSend,
 {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         self.rows
             .iter()
             .filter_map(|row| row.key.matches(tokens, source))

harper-core/src/patterns/repeating_pattern.rs

@@ -1,5 +1,3 @@
-use std::num::NonZeroUsize;
-
 use super::Pattern;
 use crate::Token;
 
@@ -21,18 +19,25 @@ impl RepeatingPattern {
 }
 
 impl Pattern for RepeatingPattern {
-    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<NonZeroUsize> {
+    fn matches(&self, tokens: &[Token], source: &[char]) -> Option<usize> {
         let mut tok_cursor = 0;
         let mut repetition = 0;
 
         loop {
             let match_len = self.inner.matches(&tokens[tok_cursor..], source);
 
             if let Some(match_len) = match_len {
-                tok_cursor += match_len.get();
+                if match_len == 0 {
+                    // If match_len == 0, we won't move forward ever again.
+                    // This means that we can get infinitely many repetitions,
+                    // so repetition >= self.required_repetitions is guaranteed.
+                    return Some(tok_cursor);
+                }
+
+                tok_cursor += match_len;
                 repetition += 1;
             } else if repetition >= self.required_repetitions {
-                return NonZeroUsize::new(tok_cursor);
+                return Some(tok_cursor);
             } else {
                 return None;
             }
@@ -42,7 +47,6 @@ impl Pattern for RepeatingPattern {
 
 #[cfg(test)]
 mod tests {
-    use std::num::NonZeroUsize;
 
     use super::RepeatingPattern;
     use crate::Document;
@@ -57,7 +61,7 @@ mod tests {
 
         assert_eq!(
             pat.matches(doc.get_tokens(), doc.get_source()),
-            NonZeroUsize::new(doc.get_tokens().len())
+            Some(doc.get_tokens().len())
         )
     }