yeast: Remove support for fresh literals

We don't use these, and have no immediate plans to do so either, so in
the interest of cleaning things up, I'm getting rid of this now. We can
always add them back later if necessary.

Author: tausbn

shared/yeast-macros/src/lib.rs

@@ -40,7 +40,6 @@ pub fn query(input: TokenStream) -> TokenStream {
 /// ```text
 /// (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, dispatched via
 ///                                the `IntoFieldIds` trait: `Id` pushes a
 ///                                single id; iterables (`Vec<Id>`,

shared/yeast-macros/src/parse.rs

@@ -422,7 +422,7 @@ fn parse_direct_node(
 }
 
 /// Parse the inside of a parenthesized node: `kind fields... children...`
-/// or `kind "literal"` or `kind $fresh`.
+/// or `kind "literal"`.
 fn parse_direct_node_inner(
     tokens: &mut Tokens,
     ctx: &Ident,
@@ -474,14 +474,6 @@ fn parse_direct_node_inner(
         });
     }
 
-    // Check for (kind $fresh)
-    if peek_is_dollar(tokens) {
-        tokens.next();
-        let name = expect_ident(tokens, "expected fresh variable name after $")?;
-        let name_str = name.to_string();
-        return Ok(quote! { #ctx.fresh(#kind_str, #name_str) });
-    }
-
     // Parse named fields
     let mut stmts = Vec::new();
     let mut field_args = Vec::new();
@@ -973,7 +965,7 @@ pub fn parse_rule_top(input: TokenStream) -> Result<TokenStream> {
                     let #ctx_ident = __user_ctx;
                     Ok(#guard)
                 }),
-                Box::new(|__ast: &mut yeast::Ast, mut __captures: yeast::captures::Captures, __fresh: &yeast::tree_builder::FreshScope, __source_range: Option<yeast::Range>, __user_ctx: &mut _, __translator: yeast::TranslatorHandle<'_, _>| {
+                Box::new(|__ast: &mut yeast::Ast, mut __captures: yeast::captures::Captures, __source_range: Option<yeast::Range>, __user_ctx: &mut _, __translator: yeast::TranslatorHandle<'_, _>| {
                     // Auto-translation prefix: recursively translate every
                     // captured node before invoking the user's transform body,
                     // except for `@@name` captures listed in `__skip` which the
@@ -985,7 +977,7 @@ pub fn parse_rule_top(input: TokenStream) -> Result<TokenStream> {
                     __translator.auto_translate_captures(&mut __captures, __ast, __user_ctx, __skip)?;
                     #(#raw_bindings)*
                     #(#translated_bindings)*
-                    let mut #ctx_ident = yeast::build::BuildCtx::with_translator(__ast, &__captures, __fresh, __source_range, __user_ctx, __translator);
+                    let mut #ctx_ident = yeast::build::BuildCtx::with_translator(__ast, &__captures, __source_range, __user_ctx, __translator);
                     let __result: Vec<yeast::Id> = { #transform_body };
                     let __result = #ctx_ident.finish_rule(__result);
                     Ok(__result)
@@ -1048,10 +1040,6 @@ fn peek_is_literal(tokens: &mut Tokens) -> bool {
     matches!(tokens.peek(), Some(TokenTree::Literal(_)))
 }
 
-fn peek_is_dollar(tokens: &mut Tokens) -> bool {
-    matches!(tokens.peek(), Some(TokenTree::Punct(p)) if p.as_char() == '$')
-}
-
 fn peek_is_hash(tokens: &mut Tokens) -> bool {
     matches!(tokens.peek(), Some(TokenTree::Punct(p)) if p.as_char() == '#')
 }

shared/yeast/doc/yeast.md

@@ -184,8 +184,8 @@ yeast::rule!(
 );
 
 // Standalone — explicit context
-let fresh = yeast::tree_builder::FreshScope::new();
-let mut ctx = BuildCtx::new(ast, &captures, &fresh);
+let mut user_ctx = ();
+let mut ctx = BuildCtx::new(ast, &captures, &mut user_ctx);
 let id = yeast::tree!(ctx,
     (assignment
         left: {ctx.capture("lhs")}
@@ -374,25 +374,6 @@ Outside a `?`, interpolating an `Option` with `#{expr}` remains a compile error.
 That is deliberate: it keeps the choice between "leave the field unset" and
 "unwrap it" explicit at every interpolation.
 
-### Fresh identifiers
-
-`(kind $name)` creates a leaf node with an auto-generated unique name. All
-occurrences of the same `$name` within one `BuildCtx` share the same value:
-
-```rust
-(block
-    parameters: (block_parameters
-        (identifier $tmp)         // generates e.g. "$tmp-0"
-    )
-    body: (block_body
-        (assignment
-            left: {pat}
-            right: (identifier $tmp)   // same "$tmp-0" value
-        )
-    )
-)
-```
-
 ### Embedded Rust expressions
 
 `{expr}` embeds a Rust expression whose value is appended to the
@@ -479,43 +460,6 @@ Mix `@` and `@@` freely in the same rule. In a Repeating phase both
 markers are equivalent (auto-translation is a no-op for repeating
 rules).
 
-## Complete example: for-loop desugaring
-
-This rule rewrites Ruby's `for pat in val do body end` into
-`val.each { |tmp| pat = tmp; body }`:
-
-```rust
-let for_rule = yeast::rule!(
-    (for
-        pattern: (_) @pat
-        value: (in (_) @val)
-        body: (do (_)* @body)
-    )
-    =>
-    (call
-        receiver: {val}
-        method: (identifier "each")
-        block: (block
-            parameters: (block_parameters
-                (identifier $tmp)
-            )
-            body: (block_body
-                (assignment
-                    left: {pat}
-                    right: (identifier $tmp)
-                )
-                {..body}
-            )
-        )
-    )
-);
-```
-
-Captures from the query (`@pat`, `@val`, `@body`) become Rust variables
-automatically: single captures bind as `Id`, repeated captures (after
-`*` or `+`) as `Vec<Id>`, and optional captures (after `?`) as
-`Option<Id>`.
-
 ## The `rule!` macro
 
 `rule!` combines a query and a transform into a single declaration.

shared/yeast/src/build.rs

@@ -1,15 +1,13 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use crate::captures::Captures;
-use crate::tree_builder::FreshScope;
 use crate::{Ast, FieldId, Id, KindId, NodeContent, Range, TranslatorHandle};
 
 /// Context for building new AST nodes during a transformation.
 ///
 /// Used by the `tree!` and `trees!` macros. Holds a mutable reference to the
-/// AST, a reference to the captures from a query match, a `FreshScope` for
-/// generating unique identifiers, and a mutable reference to a user-defined
-/// context of type `C`.
+/// AST, a reference to the captures from a query match, and a mutable reference
+/// to a user-defined context of type `C`.
 ///
 /// The user context `C` is shared across rules via the framework's driver:
 /// outer rules can write to it before recursive translation, and inner rules
@@ -32,7 +30,6 @@ use crate::{Ast, FieldId, Id, KindId, NodeContent, Range, TranslatorHandle};
 pub struct BuildCtx<'a, C: 'a = ()> {
     pub ast: &'a mut Ast,
     pub captures: &'a Captures,
-    pub fresh: &'a FreshScope,
     /// Source range of the node matched by the current rule.
     ///
     /// The `rule!` macro applies this range to locally-created result roots
@@ -54,16 +51,10 @@ pub struct BuildCtx<'a, C: 'a = ()> {
 }
 
 impl<'a, C> BuildCtx<'a, C> {
-    pub fn new(
-        ast: &'a mut Ast,
-        captures: &'a Captures,
-        fresh: &'a FreshScope,
-        user_ctx: &'a mut C,
-    ) -> Self {
+    pub fn new(ast: &'a mut Ast, captures: &'a Captures, user_ctx: &'a mut C) -> Self {
         Self {
             ast,
             captures,
-            fresh,
             source_range: None,
             user_ctx,
             translator: None,
@@ -75,14 +66,12 @@ impl<'a, C> BuildCtx<'a, C> {
     pub fn with_source_range(
         ast: &'a mut Ast,
         captures: &'a Captures,
-        fresh: &'a FreshScope,
         source_range: Option<Range>,
         user_ctx: &'a mut C,
     ) -> Self {
         Self {
             ast,
             captures,
-            fresh,
             source_range,
             user_ctx,
             translator: None,
@@ -95,15 +84,13 @@ impl<'a, C> BuildCtx<'a, C> {
     pub fn with_translator(
         ast: &'a mut Ast,
         captures: &'a Captures,
-        fresh: &'a FreshScope,
         source_range: Option<Range>,
         user_ctx: &'a mut C,
         translator: TranslatorHandle<'a, C>,
     ) -> Self {
         Self {
             ast,
             captures,
-            fresh,
             source_range,
             user_ctx,
             translator: Some(translator),
@@ -262,12 +249,6 @@ impl<'a, C> BuildCtx<'a, C> {
         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);
-        self.create_named_token_with_range(kind, generated, None)
-    }
 }
 
 impl<C: Clone> BuildCtx<'_, C> {
@@ -302,7 +283,7 @@ impl<C: Clone> BuildCtx<'_, C> {
 
     /// Run `f` with a temporary child [`BuildCtx`] whose `user_ctx` is
     /// a fresh clone of the current one, sharing everything else
-    /// (`ast`, `captures`, `fresh`, source ranges, `translator`) by re-borrow.
+    /// (`ast`, `captures`, source ranges, `translator`) by re-borrow.
     /// Nodes constructed through the child remain part of the current rule
     /// invocation. Any mutations `f` makes to the child's `user_ctx`
     /// are discarded when it returns — no restore needed, because the
@@ -334,7 +315,6 @@ impl<C: Clone> BuildCtx<'_, C> {
         let mut child = BuildCtx {
             ast: &mut *self.ast,
             captures: self.captures,
-            fresh: self.fresh,
             source_range: self.source_range,
             user_ctx: &mut child_user_ctx,
             translator: self.translator,