refactor: towards regex-style captures

harper-core/src/expr/mod.rs

@@ -173,3 +173,7 @@ where
         LongestMatchOf::new(vec![Box::new(self), Box::new(other)])
     }
 }
+
+pub struct MatchInfo<'a> {
+    pub matched_tokens: &'a [Token],
+}

harper-core/src/linting/a_part.rs

@@ -1,8 +1,9 @@
 use crate::expr::Expr;
 use crate::expr::FirstMatchOf;
 use crate::expr::FixedPhrase;
+use crate::expr::MatchInfo;
 use crate::{
-    Token, TokenStringExt,
+    TokenStringExt,
     linting::{ExprLinter, Lint, LintKind, Suggestion},
 };
 
@@ -30,7 +31,8 @@ impl ExprLinter for APart {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         let span = matched_tokens.span()?;
         let text: String = span.get_content(source).iter().collect();
         let text_lower = text.to_lowercase();

harper-core/src/linting/adjective_double_degree.rs

@@ -1,6 +1,6 @@
 use crate::{
     CharStringExt, Token, TokenStringExt,
-    expr::{Expr, SequenceExpr},
+    expr::{Expr, MatchInfo, SequenceExpr},
     linting::{ExprLinter, Lint, LintKind, Suggestion},
 };
 
@@ -25,7 +25,8 @@ impl ExprLinter for AdjectiveDoubleDegree {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         let phrase_span = toks.span()?;
         let phrase_chars = phrase_span.get_content(src);
 

harper-core/src/linting/am_in_the_morning.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Span, Token, TokenStringExt,
-    expr::{Expr, FixedPhrase, LongestMatchOf, SequenceExpr},
+    Span, TokenStringExt,
+    expr::{Expr, FixedPhrase, LongestMatchOf, MatchInfo, SequenceExpr},
     linting::{ExprLinter, Lint, LintKind, Suggestion},
     patterns::WordSet,
 };
@@ -44,7 +44,8 @@ impl ExprLinter for AmInTheMorning {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         let all_after_number_span = toks[0..].span()?;
         let am_pm_idx = if toks[0].kind.is_whitespace() { 1 } else { 0 };
 

harper-core/src/linting/amounts_for.rs

@@ -1,8 +1,9 @@
 use crate::expr::Expr;
 use crate::expr::FirstMatchOf;
 use crate::expr::FixedPhrase;
+use crate::expr::MatchInfo;
 use crate::expr::SequenceExpr;
-use crate::{Token, TokenStringExt, patterns::WordSet};
+use crate::{TokenStringExt, patterns::WordSet};
 
 use super::{ExprLinter, Lint, LintKind, Suggestion};
 
@@ -42,7 +43,8 @@ impl ExprLinter for AmountsFor {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         let content = toks.span()?.get_content_string(src).to_lowercase();
 
         if content.ends_with("amounts for") {

harper-core/src/linting/another_thing_coming.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Token, TokenStringExt,
-    expr::{Expr, FixedPhrase, SequenceExpr},
+    TokenStringExt,
+    expr::{Expr, FixedPhrase, MatchInfo, SequenceExpr},
     linting::{ExprLinter, Lint, LintKind, Suggestion},
     patterns::WordSet,
 };
@@ -27,7 +27,8 @@ impl ExprLinter for AnotherThingComing {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         Some(Lint {
             span: toks[2..].span()?,
             lint_kind: LintKind::WordChoice,

harper-core/src/linting/another_think_coming.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Token, TokenStringExt,
-    expr::{Expr, FixedPhrase, SequenceExpr},
+    TokenStringExt,
+    expr::{Expr, FixedPhrase, MatchInfo, SequenceExpr},
     linting::{ExprLinter, Lint, LintKind, Suggestion},
     patterns::WordSet,
 };
@@ -27,7 +27,8 @@ impl ExprLinter for AnotherThinkComing {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         Some(Lint {
             span: toks[2..].span()?,
             lint_kind: LintKind::WordChoice,

harper-core/src/linting/ask_no_preposition.rs

@@ -1,7 +1,8 @@
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::SequenceExpr;
 use crate::{
-    Span, Token,
+    Span,
     linting::{ExprLinter, Lint, LintKind, Suggestion},
     patterns::WordSet,
 };
@@ -36,7 +37,8 @@ impl ExprLinter for AskNoPreposition {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         if toks.len() < 5 {
             return None;
         }

harper-core/src/linting/avoid_curses.rs

@@ -1,5 +1,4 @@
-use crate::Token;
-use crate::expr::{Expr, SequenceExpr};
+use crate::expr::{Expr, MatchInfo, SequenceExpr};
 use crate::linting::{LintKind, Suggestion};
 
 use super::{ExprLinter, Lint};
@@ -21,7 +20,8 @@ impl ExprLinter for AvoidCurses {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         if toks.len() != 1 {
             return None;
         }

harper-core/src/linting/back_in_the_day.rs

@@ -1,9 +1,10 @@
 use crate::expr::Expr;
 use crate::expr::FixedPhrase;
+use crate::expr::MatchInfo;
 use crate::expr::OwnedExprExt;
 use crate::expr::SequenceExpr;
 use crate::{
-    Lrc, Token, TokenStringExt,
+    Lrc, TokenStringExt,
     patterns::{Pattern, WordSet},
 };
 
@@ -38,7 +39,8 @@ impl ExprLinter for BackInTheDay {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         if let Some(tail) = matched_tokens.get(8..)
             && self.exceptions.matches(tail, source).is_some()
         {

harper-core/src/linting/best_of_all_time.rs

@@ -1,5 +1,4 @@
-use crate::Token;
-use crate::expr::{Expr, SequenceExpr};
+use crate::expr::{Expr, MatchInfo, SequenceExpr};
 use crate::patterns::WhitespacePattern;
 
 use super::{ExprLinter, Lint, LintKind, Suggestion};
@@ -41,7 +40,8 @@ impl ExprLinter for BestOfAllTime {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         let times_span = toks.last()?.span;
 
         if let Some((_, time_singular)) = times_span.get_content(src).split_last() {

harper-core/src/linting/boring_words.rs

@@ -1,5 +1,5 @@
-use crate::expr::{Expr, WordExprGroup};
-use crate::{Token, TokenStringExt};
+use crate::TokenStringExt;
+use crate::expr::{Expr, MatchInfo, WordExprGroup};
 
 use super::{ExprLinter, Lint, LintKind};
 
@@ -28,7 +28,8 @@ impl ExprLinter for BoringWords {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         let matched_word = matched_tokens.span()?.get_content_string(source);
 
         Some(Lint {

harper-core/src/linting/cant.rs

@@ -1,6 +1,6 @@
 use super::{ExprLinter, Suggestion};
 use crate::Lint;
-use crate::expr::{Expr, LongestMatchOf, SequenceExpr};
+use crate::expr::{Expr, LongestMatchOf, MatchInfo, SequenceExpr};
 use crate::linting::LintKind;
 use crate::linting::expr_linter::find_the_only_token_matching;
 use crate::{CharStringExt, Token};
@@ -52,7 +52,8 @@ impl ExprLinter for Cant {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, toks: &[Token], src: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, src: &[char]) -> Option<Lint> {
+        let toks = match_info.matched_tokens;
         let token = find_the_only_token_matching(toks, src, |tok, src| {
             tok.span
                 .get_content(src)

harper-core/src/linting/chock_full.rs

@@ -1,7 +1,8 @@
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::SequenceExpr;
 use crate::expr::SpaceOrHyphen;
-use crate::{Token, TokenStringExt, patterns::WordSet};
+use crate::{TokenStringExt, patterns::WordSet};
 
 use super::{ExprLinter, Lint, LintKind, Suggestion};
 
@@ -27,7 +28,8 @@ impl ExprLinter for ChockFull {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_toks: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_toks = match_info.matched_tokens;
         let span = matched_toks.span()?;
 
         Some(Lint {

harper-core/src/linting/compound_nouns/compound_noun_after_det_adj.rs

@@ -1,5 +1,6 @@
 use crate::expr::All;
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::MergeableWords;
 use crate::expr::SequenceExpr;
 use crate::{CharStringExt, TokenStringExt, linting::ExprLinter};
@@ -57,7 +58,8 @@ impl ExprLinter for CompoundNounAfterDetAdj {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         if matched_tokens
             .first()?
             .span

harper-core/src/linting/compound_nouns/compound_noun_after_possessive.rs

@@ -1,14 +1,13 @@
 use crate::expr::All;
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::MergeableWords;
 use crate::expr::SequenceExpr;
 use crate::patterns::AnyPattern;
 use crate::{CharStringExt, Lrc, TokenStringExt, linting::ExprLinter};
 
 use super::{Lint, LintKind, Suggestion, is_content_word, predicate};
 
-use crate::Token;
-
 /// Looks for closed compound nouns which can be condensed due to their position after a
 /// possessive noun (which implies ownership).
 /// See also:
@@ -56,7 +55,8 @@ impl ExprLinter for CompoundNounAfterPossessive {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         // "Let's" can technically be a possessive noun (of a lease, or a let in tennis, etc.)
         // but in practice it's almost always a contraction of "let us" before a verb
         // or a mistake for "lets", the 3rd person singular present form of "to let".

harper-core/src/linting/compound_nouns/compound_noun_before_aux_verb.rs

@@ -1,14 +1,13 @@
 use crate::expr::All;
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::MergeableWords;
 use crate::expr::SequenceExpr;
 use crate::patterns::AnyPattern;
 use crate::{CharStringExt, Lrc, TokenStringExt, linting::ExprLinter};
 
 use super::{Lint, LintKind, Suggestion, is_content_word, predicate};
 
-use crate::Token;
-
 /// Two adjacent words separated by whitespace that if joined would be a valid noun.
 pub struct CompoundNounBeforeAuxVerb {
     expr: Box<dyn Expr>,
@@ -48,7 +47,8 @@ impl ExprLinter for CompoundNounBeforeAuxVerb {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         let span = matched_tokens[0..3].span()?;
         let orig = span.get_content(source);
         // If the pattern matched, this will not return `None`.

harper-core/src/linting/confident.rs

@@ -1,4 +1,5 @@
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::OwnedExprExt;
 use crate::expr::SequenceExpr;
 use crate::{Token, patterns::Word};
@@ -32,7 +33,8 @@ impl ExprLinter for Confident {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], _source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, _source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         let span = matched_tokens.last()?.span;
 
         Some(Lint {

harper-core/src/linting/dashes.rs

@@ -1,7 +1,8 @@
+use crate::TokenStringExt;
 use crate::expr::Expr;
 use crate::expr::LongestMatchOf;
+use crate::expr::MatchInfo;
 use crate::expr::SequenceExpr;
-use crate::{Token, TokenStringExt};
 
 use super::{ExprLinter, Lint, LintKind, Suggestion};
 
@@ -33,7 +34,8 @@ impl ExprLinter for Dashes {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched_tokens: &[Token], _source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, _source: &[char]) -> Option<Lint> {
+        let matched_tokens = match_info.matched_tokens;
         let span = matched_tokens.span()?;
         let lint_kind = LintKind::Formatting;
 

harper-core/src/linting/despite_of.rs

@@ -1,6 +1,7 @@
+use crate::TokenStringExt;
 use crate::expr::Expr;
+use crate::expr::MatchInfo;
 use crate::expr::SequenceExpr;
-use crate::{Token, TokenStringExt};
 
 use super::{ExprLinter, Lint, LintKind, Suggestion};
 
@@ -25,7 +26,8 @@ impl ExprLinter for DespiteOf {
         self.expr.as_ref()
     }
 
-    fn match_to_lint(&self, matched: &[Token], source: &[char]) -> Option<Lint> {
+    fn match_to_lint(&self, match_info: MatchInfo<'_>, source: &[char]) -> Option<Lint> {
+        let matched = match_info.matched_tokens;
         let span = matched.span()?;
         let matched = span.get_content(source);