feat: add within until

crates/core/src/pattern_compiler/within_compiler.rs

@@ -20,7 +20,12 @@ impl NodeCompiler for WithinCompiler {
         let within = node
             .child_by_field_name("pattern")
             .ok_or_else(|| anyhow!("missing pattern of pattern within"))?;
+
         let within = PatternCompiler::from_node(&within, context)?;
-        Ok(Within::new(within))
+        let until = node
+            .child_by_field_name("until")
+            .map(|n| PatternCompiler::from_node(&n, context))
+            .transpose()?;
+        Ok(Within::new(within, until))
     }
 }

crates/core/src/test.rs

@@ -7398,6 +7398,56 @@ fn simple_until() {
     .unwrap();
 }
 
+#[test]
+fn within_until() {
+    run_test_expected({
+        TestArgExpected {
+            pattern: r#"
+                |language js
+                |
+                |contains bubble `foo($x)` => `bar($x)` where {
+                |   $x <: within `wrapped($_)` until `stop($_)`
+                |}
+                |"#
+            .trim_margin()
+            .unwrap(),
+            source: r#"
+                |// not match:
+                |foo(10)
+                |// this will match, since it is inside a wrapped
+                |wrapped(() => {
+                |   foo(11)
+                |})
+                |// this will not match, since the wrap is outside the stop
+                |wrapped(() => {
+                |   stop(() => {
+                |      foo(12)
+                |   })
+                |})
+                |"#
+            .trim_margin()
+            .unwrap(),
+            expected: r#"
+                |// not match:
+                |foo(10)
+                |// this will match, since it is inside a wrapped
+                |wrapped(() => {
+                |   bar(11)
+                |})
+                |// this will not match, since the wrap is outside the stop
+                |wrapped(() => {
+                |   stop(() => {
+                |      foo(12)
+                |   })
+                |})
+                |"#
+            .trim_margin()
+            .unwrap(),
+        }
+    })
+    .unwrap();
+}
+
 #[test]
 fn capitalize_no_args() {
     let pattern = r#"

crates/grit-pattern-matcher/src/pattern/within.rs

@@ -10,11 +10,12 @@ use grit_util::{error::GritResult, AnalysisLogs, AstNode};
 #[derive(Debug, Clone)]
 pub struct Within<Q: QueryContext> {
     pub pattern: Pattern<Q>,
+    until: Option<Pattern<Q>>,
 }
 
 impl<Q: QueryContext> Within<Q> {
-    pub fn new(pattern: Pattern<Q>) -> Self {
-        Self { pattern }
+    pub fn new(pattern: Pattern<Q>, until: Option<Pattern<Q>>) -> Self {
+        Self { pattern, until }
     }
 }
 
@@ -50,15 +51,21 @@ impl<Q: QueryContext> Matcher<Q> for Within<Q> {
         };
         for n in node.ancestors() {
             let state = cur_state.clone();
-            if self.pattern.execute(
-                &ResolvedPattern::from_node_binding(n),
-                &mut cur_state,
-                context,
-                logs,
-            )? {
+            let resolved = ResolvedPattern::from_node_binding(n);
+            if self
+                .pattern
+                .execute(&resolved, &mut cur_state, context, logs)?
+            {
                 did_match = true;
+                break;
             } else {
                 cur_state = state;
+
+                if let Some(until) = &self.until {
+                    if until.execute(&resolved, &mut cur_state, context, logs)? {
+                        break;
+                    }
+                }
             }
         }
         if did_match {