yeast: Miscellaneous cleanup

shared/tree-sitter-extractor/src/extractor/mod.rs

@@ -66,7 +66,7 @@ impl<'a> AstNode for Node<'a> {
 
 impl AstNode for yeast::Node {
     fn kind(&self) -> &str {
-        yeast::Node::kind(self)
+        yeast::Node::kind_name(self)
     }
     fn is_named(&self) -> bool {
         yeast::Node::is_named(self)
@@ -882,7 +882,6 @@ fn emit_extras_in(visitor: &mut Visitor, node: Node<'_>) {
 }
 
 fn traverse_yeast(tree: &yeast::Ast, visitor: &mut Visitor) {
-    use yeast::Cursor;
     let mut cursor = tree.walk();
     visitor.enter_node(cursor.node());
     let mut recurse = true;

shared/yeast-macros/src/lib.rs

@@ -41,22 +41,14 @@ pub fn query(input: TokenStream) -> TokenStream {
 /// (kind "literal")             - leaf with static content
 /// (kind #{expr})               - leaf with computed content (expr.to_string())
 /// (kind $fresh)                - leaf with auto-generated unique name
-/// {expr}                       - embed a Rust expression returning Id
-/// {..expr}                     - splice an iterable of Id (in child/field position)
-/// field: {..expr}              - splice into a named field
-/// {expr}.map(p -> tpl)         - apply tpl to each element; splice result
-/// {expr}.reduce_left(f -> init, acc, e -> fold)
-///                              - fold with per-element init; splice 0 or 1 result
+/// {expr}                       - embed a Rust expression, dispatched via
+///                                the `IntoFieldIds` trait: `Id` pushes a
+///                                single id; iterables (`Vec<Id>`,
+///                                `Option<Id>`, iterator chains) splice
+///                                their elements
+/// field: {expr}                - extend a named field with `{expr}`'s ids
 /// ```
 ///
-/// Chain syntax after `{expr}` or `{..expr}`:
-/// - `.map(param -> template)` — one output node per input element.
-/// - `.reduce_left(first -> init, acc, elem -> fold)` — fold left; the first
-///   element is converted by `init`, subsequent elements are folded by `fold`
-///   with the accumulator bound to `acc`. An empty iterable yields nothing.
-/// - Chains always splice (the result is iterable).
-/// - Multiple chains can be chained, e.g. `.map(...).reduce_left(...)`.
-///
 /// Can be called with an explicit context or using the implicit context
 /// from an enclosing `rule!`:
 ///
@@ -100,7 +92,7 @@ pub fn trees(input: TokenStream) -> TokenStream {
 /// rule!(
 ///     (query_pattern field: (_) @name (kind)* @repeated (_)? @optional)
 ///     =>
-///     (output_template field: {name} {..repeated})
+///     (output_template field: {name} {repeated})
 /// )
 ///
 /// // Shorthand: captures become fields on the output node

shared/yeast/doc/yeast.md

@@ -214,7 +214,7 @@ yeast::tree!(ctx,
 ```rust
 yeast::trees!(ctx,
     (assignment left: {tmp} right: {right})
-    {..body}
+    {body}
 )
 ```
 
@@ -256,12 +256,26 @@ occurrences of the same `$name` within one `BuildCtx` share the same value:
 
 ### Embedded Rust expressions
 
-`{expr}` embeds a Rust expression that returns a single node `Id`:
+`{expr}` embeds a Rust expression whose value is appended to the
+enclosing field (or to the rule body's id list). Dispatch happens via
+the [`IntoFieldIds`] trait, which is implemented for:
+
+- `Id` — pushes the single id.
+- Any `IntoIterator<Item: Into<Id>>` — extends with all yielded ids
+  (covers `Vec<Id>`, `Option<Id>`, iterator chains, etc.).
+
+So the same `{expr}` syntax handles single ids, splices, and zero-or-many
+options uniformly:
 
 ```rust
 (assignment
-    left: {some_node_id}       // insert a pre-built node
-    right: {rhs}               // insert a captured value (inside rule!)
+    left: {some_node_id}       // a single Id
+    right: {rhs}               // a captured value (inside rule!)
+)
+
+yeast::trees!(ctx,
+    (assignment left: {tmp} right: {right})
+    {extra_nodes}              // splices a Vec<Id>
 )
 ```
 
@@ -277,21 +291,17 @@ expressions (with `let` bindings) work too:
     })
 ```
 
-`{..expr}` splices a `Vec<Id>` (or any iterable of `Id`); the contents
-are likewise a Rust block, so the splice can be the result of arbitrary
-computation:
+Inside `rule!`, captures are Rust variables — `{name}` works for
+single, optional, and repeated captures alike:
 
 ```rust
-yeast::trees!(ctx,
-    (assignment left: {tmp} right: {right})
-    {..extra_nodes}                        // splice a Vec<Id>
+rule!(
+    (assignment left: @lhs right: _* @parts)
+    =>
+    (assignment left: {lhs} right: (block stmt: {parts}))
 )
 ```
 
-Inside `rule!`, captures are Rust variables, so `{name}` inserts a
-single capture (`Id`) and `{..name}` splices a repeated capture
-(`Vec<Id>`).
-
 ### Raw captures (`@@name`)
 
 The default `@name` capture marker is *auto-translated*: in OneShot
@@ -302,15 +312,15 @@ already conforms to the output schema.
 For rules that need the raw (input-schema) capture — typically to read
 its source text or to translate it explicitly with mutable context
 state between calls — use `@@name` instead. The body sees the original
-input-schema `NodeRef`:
+input-schema `Id`:
 
 ```rust
 yeast::rule!(
     (assignment left: (_) @@raw_lhs right: (_) @rhs)
     =>
     {
         // raw_lhs is untranslated: read its original source text.
-        let text = ctx.ast.source_text(raw_lhs.into());
+        let text = ctx.ast.source_text(raw_lhs);
         // rhs is already translated by the auto-translate prefix.
         tree!((call
             method: (identifier #{text.as_str()})

shared/yeast/src/build.rs

@@ -158,15 +158,6 @@ impl<'a, C> BuildCtx<'a, C> {
         self.ast
             .create_named_token_with_range(kind, generated, self.source_range)
     }
-
-    /// Prepend a value to a field of an existing node.
-    pub fn prepend_field(&mut self, node_id: Id, field_name: &str, value_id: Id) {
-        let field_id = self
-            .ast
-            .field_id_for_name(field_name)
-            .unwrap_or_else(|| panic!("build: field '{field_name}' not found"));
-        self.ast.prepend_field_child(node_id, field_id, value_id);
-    }
 }
 
 impl<C: Clone> BuildCtx<'_, C> {
@@ -176,9 +167,6 @@ impl<C: Clone> BuildCtx<'_, C> {
     /// (translation is not meaningful when input and output share a
     /// schema).
     ///
-    /// Accepts any value convertible to [`Id`] (including [`crate::NodeRef`]),
-    /// so manual rules can pass capture bindings directly without unwrapping.
-    ///
     /// Errors if this `BuildCtx` was constructed by hand (without a
     /// translator handle) — for example, in unit tests that don't go
     /// through the rule driver.
@@ -189,20 +177,6 @@ impl<C: Clone> BuildCtx<'_, C> {
             None => Err("translate() called on a BuildCtx without a translator handle".into()),
         }
     }
-
-    /// Translate an optional capture, returning the first translated id or
-    /// `None`. Convenience for `?`-quantifier captures (`Option<NodeRef>`).
-    ///
-    /// If the underlying translation produces multiple ids for a single
-    /// input, only the first is returned. For most use cases (e.g.
-    /// translating a single type annotation) this is what you want; if
-    /// you need all ids, use [`translate`] directly.
-    pub fn translate_opt<I: Into<Id>>(&mut self, id: Option<I>) -> Result<Option<Id>, String> {
-        match id {
-            Some(id) => Ok(self.translate(id)?.into_iter().next()),
-            None => Ok(None),
-        }
-    }
 }
 
 impl<C> std::ops::Deref for BuildCtx<'_, C> {

shared/yeast/src/captures.rs

@@ -54,37 +54,15 @@ impl Captures {
         self.captures.entry(key).or_default().push(id);
     }
 
-    pub fn map_captures(&mut self, kind: &str, f: &mut impl FnMut(Id) -> Id) {
-        if let Some(ids) = self.captures.get_mut(kind) {
-            for id in ids {
-                *id = f(*id);
-            }
-        }
-    }
-
-    /// Apply a fallible function to every captured id (across all keys),
-    /// replacing each id with the results. A function returning an empty
-    /// vector removes the capture; returning multiple ids splices them
-    /// into the capture's value list (suitable for `*`/`+` captures).
-    /// Stops and returns the error on the first failure.
-    pub fn try_map_all_captures<E>(
-        &mut self,
-        mut f: impl FnMut(Id) -> Result<Vec<Id>, E>,
-    ) -> Result<(), E> {
-        for ids in self.captures.values_mut() {
-            let mut new_ids = Vec::with_capacity(ids.len());
-            for &id in ids.iter() {
-                new_ids.extend(f(id)?);
-            }
-            *ids = new_ids;
-        }
-        Ok(())
-    }
-
-    /// Like [`try_map_all_captures`] but leaves captures whose name appears
-    /// in `skip` untouched. Used by the `rule!` macro to support `@@name`
-    /// (raw) captures alongside the default auto-translated `@name`
-    /// captures.
+    /// Apply a fallible function to every captured id, replacing each id
+    /// with the results. A function returning an empty vector removes
+    /// the capture; returning multiple ids splices them into the
+    /// capture's value list (suitable for `*`/`+` captures). Captures
+    /// whose name appears in `skip` are left untouched. Stops and
+    /// returns the error on the first failure.
+    ///
+    /// Used by the `rule!` macro's auto-translate prefix to translate
+    /// every capture except those marked `@@name` (raw).
     pub fn try_map_captures_except<E>(
         &mut self,
         skip: &[&str],
@@ -102,12 +80,6 @@ impl Captures {
         }
         Ok(())
     }
-    pub fn map_captures_to(&mut self, from: &str, to: &'static str, f: &mut impl FnMut(Id) -> Id) {
-        if let Some(from_ids) = self.captures.get(from) {
-            let new_values = from_ids.iter().copied().map(f).collect();
-            self.captures.insert(to, new_values);
-        }
-    }
 
     pub fn merge(&mut self, other: &Captures) {
         for (key, ids) in &other.captures {

shared/yeast/src/dump.rs

@@ -1,6 +1,6 @@
 use std::fmt::Write;
 
-use crate::{schema::Schema, Ast, Node, NodeContent, CHILD_FIELD};
+use crate::{schema::Schema, Ast, Id, Node, NodeContent, CHILD_FIELD};
 
 /// Options for controlling AST dump output.
 pub struct DumpOptions {
@@ -34,16 +34,11 @@ impl Default for DumpOptions {
 ///         method:
 ///           identifier "foo"
 /// ```
-pub fn dump_ast(ast: &Ast, root: usize, source: &str) -> String {
+pub fn dump_ast(ast: &Ast, root: Id, source: &str) -> String {
     dump_ast_with_options(ast, root, source, &DumpOptions::default())
 }
 
-pub fn dump_ast_with_options(
-    ast: &Ast,
-    root: usize,
-    source: &str,
-    options: &DumpOptions,
-) -> String {
+pub fn dump_ast_with_options(ast: &Ast, root: Id, source: &str, options: &DumpOptions) -> String {
     let mut out = String::new();
     dump_node(ast, root, source, options, 0, None, &mut out);
     out
@@ -53,7 +48,7 @@ pub fn dump_ast_with_options(
 ///
 /// Any node that does not match the expected type set for its parent field is
 /// rendered with a trailing `" <-- ERROR: ..."` annotation on the same line.
-pub fn dump_ast_with_type_errors(ast: &Ast, root: usize, source: &str, schema: &Schema) -> String {
+pub fn dump_ast_with_type_errors(ast: &Ast, root: Id, source: &str, schema: &Schema) -> String {
     dump_ast_with_type_errors_and_options(ast, root, source, schema, &DumpOptions::default())
 }
 
@@ -63,7 +58,7 @@ pub fn dump_ast_with_type_errors(ast: &Ast, root: usize, source: &str, schema: &
 /// rendered with a trailing `" <-- ERROR: ..."` annotation on the same line.
 pub fn dump_ast_with_type_errors_and_options(
     ast: &Ast,
-    root: usize,
+    root: Id,
     source: &str,
     schema: &Schema,
     options: &DumpOptions,
@@ -176,7 +171,7 @@ fn expected_for_field<'a>(
 
 fn dump_node(
     ast: &Ast,
-    id: usize,
+    id: Id,
     source: &str,
     options: &DumpOptions,
     indent: usize,
@@ -315,7 +310,7 @@ fn dump_node(
 /// Dump a leaf node inline (no newline prefix, caller provides context).
 fn dump_node_inline(
     ast: &Ast,
-    id: usize,
+    id: Id,
     source: &str,
     options: &DumpOptions,
     type_check: Option<(