Include elided tokens in yeast ranges

Co-authored-by: aschackmull <28296824+aschackmull@users.noreply.github.com>

Author: Copilot

shared/yeast/src/lib.rs

@@ -571,11 +571,17 @@ impl Ast {
         let source_range = match &content {
             // Parsed nodes already carry an exact source range in their content.
             NodeContent::Range(_) => source_range,
-            // Synthesized nodes derive location from children when possible,
-            // and fall back to the inherited rule-match range otherwise.
+            // Synthesized nodes derive location from both their children and
+            // the inherited rule-match range, so tokens matched by a rule but
+            // elided from its output still contribute to the replacement range.
             _ => self
                 .union_source_range_of_children(&fields)
-                .or(source_range),
+                .map_or(source_range, |child_range| {
+                    Some(match source_range {
+                        Some(source_range) => union_source_ranges(child_range, source_range),
+                        None => child_range,
+                    })
+                }),
         };
         let id = self.nodes.len();
         self.nodes.push(Node {
@@ -766,6 +772,25 @@ impl Ast {
     }
 }
 
+fn union_source_ranges(first: Range, second: Range) -> Range {
+    let (start_byte, start_point) = if first.start_byte <= second.start_byte {
+        (first.start_byte, first.start_point)
+    } else {
+        (second.start_byte, second.start_point)
+    };
+    let (end_byte, end_point) = if first.end_byte >= second.end_byte {
+        (first.end_byte, first.end_point)
+    } else {
+        (second.end_byte, second.end_point)
+    };
+    Range {
+        start_byte,
+        end_byte,
+        start_point,
+        end_point,
+    }
+}
+
 /// A node in our AST
 #[derive(PartialEq, Eq, Debug, Clone, Serialize)]
 pub struct Node {

shared/yeast/tests/test.rs

@@ -1663,6 +1663,31 @@ fn test_hash_brace_uses_capture_location_for_leaf() {
     assert_eq!(bar.end_byte(), 7);
 }
 
+/// Regression test: tokens matched by a rule but elided from the output still
+/// contribute to the source location of the synthesized replacement node.
+#[test]
+fn test_elided_tokens_contribute_to_replacement_location() {
+    let rule: Rule = rule!(
+        (call
+            method: (identifier) @name
+            receiver: (identifier) @recv
+        )
+        =>
+        (call
+            method: {name}
+        )
+    );
+
+    let ast = run_and_ast("foo.bar()", vec![rule]);
+    let root = ast.get_node(ast.get_root()).unwrap();
+    let stmt_field = ast.field_id_for_name("stmt").unwrap();
+    let call_id = root.field_children(stmt_field)[0];
+    let call = ast.get_node(call_id).unwrap();
+
+    assert_eq!(call.start_byte(), 0);
+    assert_eq!(call.end_byte(), 7);
+}
+
 // ---- `rules!` macro tests (compile-time type-checking) ----
 
 /// `rules!` should accept well-typed rules using the bare-rule-body