Help with an expression linter that matches a word plus all the words surrounding on both sides

[hippietrail]

I'm trying to match:

• foo
• a foo
• a b foo
• foo x
• foo x y
• a foo x

I've tried with and without AnchorStart and/or AnchorEnd.

use super::{ExprLinter, Suggestion};
use crate::token_string_ext::TokenStringExt;
use crate::{
    CharStringExt, Token,
    expr::{AnchorEnd, AnchorStart, Expr, Repeating, SequenceExpr},
    linting::{Lint, LintKind},
};

pub struct Damages {
    expr: Box<dyn Expr>,
}

impl Default for Damages {
    fn default() -> Self {
        let all = SequenceExpr::default()
            // .then(AnchorStart)
            .then_optional(
                SequenceExpr::default().then_one_or_more(SequenceExpr::any_word().t_ws()),
            )
            .t_aco("damages")
            .then_optional(
                SequenceExpr::default()
                    .then_one_or_more(SequenceExpr::default().t_ws().then_any_word()),
            )
            // .then(AnchorEnd)
            ;

        Self {
            expr: Box::new(all),
        }
    }
}

impl ExprLinter for Damages {
    fn expr(&self) -> &dyn Expr {
        self.expr.as_ref()
    }

    fn match_to_lint(&self, matched_tokens: &[Token], src: &[char]) -> Option<Lint> {
        eprintln!("❤️ '{}'", matched_tokens.span()?.get_content_string(src));
        let tok = matched_tokens.iter().find(|tok| {
            tok.span
                .get_content(src)
                .eq_ignore_ascii_case_str("damages")
        });

        if tok == None {
            return None;
        }

        let span = tok.unwrap().span;

        Some(Lint {
            span,
            lint_kind: LintKind::WordChoice,
            suggestions: vec![Suggestion::ReplaceWith("damage".chars().collect())],
            message: "Use the singular `damage` instead of the plural `damages`.".to_owned(),
            ..Default::default()
        })
    }

    fn description(&self) -> &'static str {
        "This linter detects plural `damages` incorrectly used in place of the singular `damage`."
    }
}

#[cfg(test)]
mod tests {
    mod full {
        use crate::linting::tests::assert_suggestion_result;

        use super::super::Damages;

        #[test]
        fn a_foo() {
            assert_suggestion_result("a damages", Damages::default(), "a damage");
        }

        #[test]
        fn ab_foo() {
            assert_suggestion_result("a b damages", Damages::default(), "a b damage");
        }

        #[test]
        fn foo_z() {
            assert_suggestion_result("damages z", Damages::default(), "damage z");
        }

        #[test]
        fn foo_yz() {
            assert_suggestion_result("damages y z", Damages::default(), "damage y z");
        }

        #[test]
        fn a_foo_z() {
            assert_suggestion_result("a damages z", Damages::default(), "a damage z");
        }
    }
}

It's ok with preceding words but fails with following words:

failures:
    linting::damages::tests::full::a_foo_z
    linting::damages::tests::full::foo_yz
    linting::damages::tests::full::foo_z

test result: FAILED. 2 passed; 3 failed; 0 ignored; 0 measured; 2589 filtered out; finished in 0.38s

Have I made a dumb mistake or is something missing from Harper to make this possible?

(The goal is to have a linter that checks for words in the context. A positive pattern with the desired word and a negative pattern with words we don't want.)

[elijah-potter]

Have I made a dumb mistake or is something missing from Harper to make this possible?

Definitely not a dumb mistake. I'm just as confused as you are. There is definitely a bug somewhere.