yeast: Add location heuristic for synthetic nodes with no location set

For such nodes, we assign them the zero-length location at the beginning
of the matched input node.

Also adds a bunch of helpers for overriding this range, in particular
source_range_of_all can be passed a selection of nodes, and produces a
range encompassing all of them, whereas literal_at_start_of and
literal_with_source_range_of create literals with the specified ranges.

For now accessing this machinery can only happen inside of Rust blocks.
If we find ourselves doing this kind of location massaging a lot, we may
want to add a bespoke syntax for it.

Author: tausbn

shared/yeast/doc/yeast.md

@@ -238,9 +238,10 @@ yeast::trees!(ctx,
 ### Source locations
 
 Captured nodes keep the locations assigned by their own translations. New
-nodes in an output template derive their locations from their children. After
-the transform completes, the matched input node's range is added only to
-locally-created nodes returned as rule results:
+nodes in an output template derive their locations from their children. A
+source-less nested node receives an empty location at the start of the matched
+input node. After the transform completes, the full matched range is added only
+to locally-created nodes returned as rule results:
 
 ```rust
 rule!(
@@ -251,10 +252,12 @@ rule!(
 ```
 
 Here `inner` derives its range from `child`, while the returned `outer` node
-also includes the full `wrapper` range. This lets replacement roots include
-elided keywords or delimiters without assigning the same broad range to every
-synthetic descendant. A transform that simply returns a translated capture
-does not widen that capture to the wrapper's range.
+also includes the full `wrapper` range. A nested node with no located children
+would instead receive an empty range at the start of `wrapper`. This lets
+replacement roots include elided keywords or delimiters without assigning the
+same broad range to every synthetic descendant. A transform that simply
+returns a translated capture does not widen that capture to the wrapper's
+range.
 
 Rust bodies can explicitly assign a default range to a synthetic subtree whose
 location cannot be derived from children:
@@ -265,6 +268,10 @@ let synthetic = ctx.with_node_source_range(ctx.matched_source_range, |ctx| {
 });
 ```
 
+For literals, `ctx.literal_with_source_range_of(...)` copies another node's
+exact range, while `ctx.literal_at_start_of(...)` creates an empty range at
+that node's start.
+
 ### Optional fields (`?`)
 
 A `?` on a field's value makes that field fallible. If a `#{expr}` anywhere

shared/yeast/src/build.rs

@@ -40,7 +40,8 @@ pub struct BuildCtx<'a, C: 'a = ()> {
     ///
     /// The `rule!` macro applies this range to locally-created result roots
     /// after the transform completes. Nested synthetic nodes derive their
-    /// ranges from their children unless `source_range` is explicitly set.
+    /// ranges from their children, falling back to an empty range at this
+    /// range's start.
     pub matched_source_range: Option<Range>,
     /// User-supplied context, accessible directly via `ctx.field` (via Deref).
     pub user_ctx: &'a mut C,
@@ -128,6 +129,16 @@ impl<'a, C> BuildCtx<'a, C> {
         let id = self
             .ast
             .create_node_with_range(kind, content, fields, is_named, source_range);
+        if self
+            .ast
+            .get_node(id)
+            .is_some_and(|node| node.source_range().is_none())
+        {
+            if let Some(source_range) = self.matched_source_range {
+                self.ast
+                    .extend_source_range(id, source_range.empty_at_start());
+            }
+        }
         if !has_explicit_source_range {
             self.created_nodes.insert(id);
         }
@@ -153,6 +164,10 @@ impl<'a, C> BuildCtx<'a, C> {
         source_range: Option<Range>,
     ) -> Id {
         let has_explicit_source_range = source_range.is_some();
+        let source_range = source_range.or_else(|| {
+            self.matched_source_range
+                .map(|range| range.empty_at_start())
+        });
         let id = self
             .ast
             .create_named_token_with_range(kind, content, source_range);
@@ -219,6 +234,25 @@ impl<'a, C> BuildCtx<'a, C> {
         self.ast.source_text(id)
     }
 
+    /// Return the source range of a parsed or synthetic node.
+    pub fn source_range_of(&self, id: Id) -> Option<Range> {
+        self.ast.get_node(id).and_then(|node| node.source_range())
+    }
+
+    /// Return the smallest source range containing all located nodes.
+    pub fn source_range_of_all(&self, ids: impl IntoIterator<Item = Id>) -> Option<Range> {
+        ids.into_iter()
+            .filter_map(|id| self.source_range_of(id))
+            .reduce(Range::union)
+    }
+
+    /// Return an empty range between two non-overlapping nodes.
+    pub fn empty_source_range_between(&self, left: Id, right: Id) -> Option<Range> {
+        let left = self.source_range_of(left)?;
+        let right = self.source_range_of(right)?;
+        (left.end_byte <= right.start_byte).then(|| left.empty_at_end())
+    }
+
     /// Create a named AST node with the given kind and fields.
     pub fn node(&mut self, kind: &str, fields: Vec<(&str, Vec<Id>)>) -> Id {
         let kind_id = self
@@ -262,6 +296,23 @@ impl<'a, C> BuildCtx<'a, C> {
         )
     }
 
+    /// Create a literal using another node's exact source range.
+    pub fn literal_with_source_range_of(
+        &mut self,
+        kind: &'static str,
+        value: &str,
+        source: Id,
+    ) -> Id {
+        let source_range = self.source_range_of(source);
+        self.literal_with_source_range(kind, value, source_range)
+    }
+
+    /// Create a literal with an empty range at another node's start.
+    pub fn literal_at_start_of(&mut self, kind: &'static str, value: &str, source: Id) -> Id {
+        let source_range = self.source_range_of(source).map(Range::empty_at_start);
+        self.literal_with_source_range(kind, value, source_range)
+    }
+
     /// Create a leaf node with an auto-generated unique name.
     pub fn fresh(&mut self, kind: &'static str, name: &str) -> Id {
         let generated = self.fresh.resolve(name);

shared/yeast/tests/test.rs

@@ -1709,6 +1709,34 @@ fn test_nested_synthetic_node_uses_child_location() {
     assert_eq!(arguments.byte_range(), 0..3);
 }
 
+/// A nested node with no explicit range or located children gets an empty
+/// location at the start of the rule's matched node.
+#[test]
+fn test_source_less_nested_node_uses_empty_match_start() {
+    let rule: Rule = rule!(
+        (call
+            method: (identifier) @name
+            receiver: (identifier) @recv
+        )
+        =>
+        (call
+            method: {name}
+            receiver: {recv}
+            arguments: (argument_list)
+        )
+    );
+
+    let ast = run_and_ast("foo.bar()", vec![rule]);
+    let arguments = ast
+        .reachable_node_ids()
+        .into_iter()
+        .filter_map(|id| ast.get_node(id))
+        .find(|node| node.kind_name() == "argument_list")
+        .expect("argument list exists");
+    let range = arguments.source_range().unwrap();
+    assert_eq!(range.start_byte..range.end_byte, 0..0);
+}
+
 /// An explicit empty range at byte zero is a real location, not the sentinel
 /// for an absent location, and therefore contributes to parent ranges.
 #[test]

unified/extractor/tests/location_tests.rs

@@ -51,6 +51,16 @@ fn assert_has_span(ast: &Ast, source: &str, kind: &str, content: Option<&str>, e
     );
 }
 
+fn assert_has_empty_span(ast: &Ast, kind: &str, content: Option<&str>, expected_offset: usize) {
+    let ranges = ranges(ast, kind, content);
+    assert!(
+        ranges
+            .iter()
+            .any(|range| range.start == expected_offset && range.end == expected_offset),
+        "expected {kind} {content:?} to have an empty span at {expected_offset}, got {ranges:?}"
+    );
+}
+
 #[test]
 fn generic_type_children_have_local_ranges() {
     let source = "let x = C<Foo>()";
@@ -61,6 +71,25 @@ fn generic_type_children_have_local_ranges() {
     assert_has_span(&ast, source, "identifier", Some("Foo"), "Foo");
 }
 
+#[test]
+fn synthetic_type_and_modifier_nodes_use_empty_scope_start_ranges() {
+    let source = "let array: [T]\nlet optional: T?\nenum E { case a, b }";
+    let ast = desugar(source);
+
+    assert_has_empty_span(&ast, "identifier", Some("Array"), source.find('[').unwrap());
+    assert_has_empty_span(
+        &ast,
+        "identifier",
+        Some("Optional"),
+        source.find("T?").unwrap(),
+    );
+    let case_a = source.find("a, b").unwrap();
+    let case_b = case_a + "a, ".len();
+    assert_has_empty_span(&ast, "modifier", Some("enum_case"), case_a);
+    assert_has_empty_span(&ast, "modifier", Some("enum_case"), case_b);
+    assert_has_empty_span(&ast, "modifier", Some("chained_declaration"), case_b);
+}
+
 #[test]
 fn import_member_chain_excludes_import_keyword() {
     let source = "import Foundation.Networking.URLSession";

unified/ql/test/library-tests/BasicTest/test.expected

@@ -2,19 +2,13 @@ identifier
 | name_expr.swift:1:5:1:5 | x | x |
 | name_expr.swift:1:9:1:9 | y | y |
 | strings.swift:1:5:1:5 | x | x |
-| test.swift:1:1:1:0 | Array | Array |
-| test.swift:1:1:1:0 | Array | Array |
-| test.swift:1:1:1:0 | Array | Array |
-| test.swift:1:1:1:0 | Array | Array |
-| test.swift:1:1:1:0 | Optional | Optional |
-| test.swift:1:1:1:0 | Optional | Optional |
-| test.swift:1:1:1:0 | Optional | Optional |
 | test.swift:1:8:1:17 | Foundation | Foundation |
 | test.swift:1:8:1:17 | Foundation | Foundation |
 | test.swift:4:8:4:16 | Container | Container |
 | test.swift:4:18:4:18 | T | T |
 | test.swift:4:21:4:29 | Equatable | Equatable |
 | test.swift:5:9:5:13 | items | items |
+| test.swift:5:16:5:15 | Array | Array |
 | test.swift:5:17:5:17 | T | T |
 | test.swift:7:19:7:21 | add | add |
 | test.swift:7:23:7:23 | _ | _ |
@@ -39,6 +33,7 @@ identifier
 | test.swift:20:15:20:16 | at | at |
 | test.swift:20:18:20:22 | index | index |
 | test.swift:20:25:20:27 | Int | Int |
+| test.swift:20:33:20:32 | Optional | Optional |
 | test.swift:20:33:20:39 | Element | Element |
 | test.swift:24:6:24:10 | merge | merge |
 | test.swift:24:12:24:12 | T | T |
@@ -49,6 +44,7 @@ identifier
 | test.swift:24:39:24:39 | _ | _ |
 | test.swift:24:41:24:46 | second | second |
 | test.swift:24:49:24:49 | T | T |
+| test.swift:24:55:24:54 | Array | Array |
 | test.swift:24:56:24:56 | T | T |
 | test.swift:24:58:24:64 | Element | Element |
 | test.swift:25:9:25:14 | result | result |
@@ -69,6 +65,7 @@ identifier
 | test.swift:36:15:36:21 | Element | Element |
 | test.swift:36:25:36:25 | T | T |
 | test.swift:37:17:37:20 | data | data |
+| test.swift:37:23:37:22 | Array | Array |
 | test.swift:37:24:37:24 | T | T |
 | test.swift:39:9:39:13 | count | count |
 | test.swift:39:16:39:18 | Int | Int |
@@ -82,6 +79,7 @@ identifier
 | test.swift:47:15:47:16 | at | at |
 | test.swift:47:18:47:22 | index | index |
 | test.swift:47:25:47:27 | Int | Int |
+| test.swift:47:33:47:32 | Optional | Optional |
 | test.swift:47:33:47:33 | T | T |
 | test.swift:48:15:48:19 | index | index |
 | test.swift:48:29:48:33 | index | index |
@@ -135,11 +133,13 @@ identifier
 | test.swift:85:14:85:14 | T | T |
 | test.swift:85:17:85:17 | _ | _ |
 | test.swift:85:19:85:24 | values | values |
+| test.swift:85:27:85:26 | Array | Array |
 | test.swift:85:28:85:28 | T | T |
 | test.swift:85:32:85:40 | transform | transform |
 | test.swift:85:44:85:44 | T | T |
 | test.swift:85:47:85:47 | T | T |
 | test.swift:85:53:85:53 | T | T |
+| test.swift:85:59:85:58 | Optional | Optional |
 | test.swift:85:59:85:59 | T | T |
 | test.swift:86:12:86:17 | values | values |
 | test.swift:86:19:86:25 | isEmpty | isEmpty |
@@ -149,7 +149,7 @@ identifier
 | test.swift:87:38:87:43 | values | values |
 | test.swift:87:49:87:57 | transform | transform |
 namedPattern
-| test.swift:1:8:1:17 | NamedPattern | Foundation |
+| test.swift:1:1:1:17 | NamedPattern | Foundation |
 unsupported
 stringValue
 | strings.swift:1:9:1:15 | "hello" | "hello" |