[skip ci] yolo

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

@@ -7406,7 +7406,7 @@ fn within_until() {
                 |language js
                 |
                 |contains bubble `foo($x)` => `bar($x)` where {
-                |   $x <: within `wrapped($x)` until `stop($_)`
+                |   $x <: within `wrapped($_)` until `stop($_)`
                 |}
                 |"#
             .trim_margin()

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 {