yeast: Remove explicit ctx from tree builders

We never used the ability to specify a different context from `ctx` in
these builders anyway, so this commit makes it so that we always use the
ambient `ctx` that is provided inside of rule bodies.

Note that if we end up needing a particular context anyway, then we can
simply reassign `ctx` before calling the tree macros. This has the same
effect as passing in a custom context would have now.

Author: tausbn

shared/yeast-macros/src/lib.rs

@@ -75,12 +75,10 @@ pub fn query(input: TokenStream) -> TokenStream {
 /// error, so the choice between "unset the field" and "unwrap it" stays
 /// explicit.
 ///
-/// Can be called with an explicit context or using the implicit context
-/// from an enclosing `rule!`:
+/// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
 ///
 /// ```text
-/// tree!(ctx, (kind ...))     // explicit BuildCtx
-/// tree!((kind ...))          // implicit context from rule!
+/// tree!((kind ...))
 /// ```
 #[proc_macro]
 pub fn tree(input: TokenStream) -> TokenStream {
@@ -96,12 +94,10 @@ pub fn tree(input: TokenStream) -> TokenStream {
 /// Like `tree!` but returns `Vec<Id>` and supports multiple top-level
 /// elements. All syntax from `tree!` is available.
 ///
-/// Can be called with an explicit context or using the implicit context
-/// from an enclosing `rule!`:
+/// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
 ///
 /// ```text
-/// trees!(ctx, (node1 ...) (node2 ...))   // explicit BuildCtx
-/// trees!((node1 ...) (node2 ...))        // implicit context from rule!
+/// trees!((node1 ...) (node2 ...))
 /// ```
 #[proc_macro]
 pub fn trees(input: TokenStream) -> TokenStream {
@@ -112,6 +108,38 @@ pub fn trees(input: TokenStream) -> TokenStream {
     }
 }
 
+/// Build one AST node whose root uses another node's source range.
+///
+/// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
+///
+/// ```text
+/// tree_at!(source, (kind ...))
+/// ```
+#[proc_macro]
+pub fn tree_at(input: TokenStream) -> TokenStream {
+    let input2: TokenStream2 = input.into();
+    match parse::parse_tree_at_top(input2) {
+        Ok(output) => output.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
+/// Build one AST node whose root spans a collection of nodes.
+///
+/// Uses the `BuildCtx` binding named `ctx` from the surrounding scope:
+///
+/// ```text
+/// tree_spanning!(sources, (kind ...))
+/// ```
+#[proc_macro]
+pub fn tree_spanning(input: TokenStream) -> TokenStream {
+    let input2: TokenStream2 = input.into();
+    match parse::parse_tree_spanning_top(input2) {
+        Ok(output) => output.into(),
+        Err(err) => err.to_compile_error().into(),
+    }
+}
+
 /// Define a desugaring rule with query and transform in one declaration.
 ///
 /// ```text
@@ -146,7 +174,7 @@ pub fn trees(input: TokenStream) -> TokenStream {
 /// Mutations to `ctx` are visible to the transform when the guard succeeds.
 /// Omitting the guard is equivalent to writing `where true`.
 ///
-/// `tree!` and `trees!` can be used without explicit context inside `{...}`.
+/// `tree!` and `trees!` use the rule transform's `ctx` binding inside `{...}`.
 #[proc_macro]
 pub fn rule(input: TokenStream) -> TokenStream {
     let input2: TokenStream2 = input.into();

shared/yeast-macros/src/parse.rs

@@ -332,28 +332,10 @@ fn parse_query_list(tokens: &mut Tokens) -> Result<Vec<TokenStream>> {
 
 const IMPLICIT_CTX: &str = "ctx";
 
-/// Determine the context identifier: either explicit `ctx,` or the implicit
-/// `ctx` from an enclosing `rule!`.
-fn parse_ctx_or_implicit(tokens: &mut Tokens) -> Ident {
-    // Check if first token is an ident followed by a comma
-    let mut lookahead = tokens.clone();
-    let is_explicit = matches!(lookahead.next(), Some(TokenTree::Ident(_)))
-        && matches!(lookahead.next(), Some(TokenTree::Punct(p)) if p.as_char() == ',');
-
-    if is_explicit {
-        let ctx = expect_ident(tokens, "unreachable: ident was just peeked")
-            .expect("unreachable: ident was just peeked");
-        let _ = tokens.next(); // consume comma
-        ctx
-    } else {
-        Ident::new(IMPLICIT_CTX, Span::call_site())
-    }
-}
-
-/// Parse `tree!(ctx, (template))` or `tree!((template))` — returns single `Id`.
+/// Parse `tree!((template))` — returns single `Id`.
 pub fn parse_tree_top(input: TokenStream) -> Result<TokenStream> {
     let mut tokens = input.into_iter().peekable();
-    let ctx = parse_ctx_or_implicit(&mut tokens);
+    let ctx = Ident::new(IMPLICIT_CTX, Span::call_site());
 
     let first = parse_direct_node(&mut tokens, &ctx, None)?;
 
@@ -368,10 +350,10 @@ pub fn parse_tree_top(input: TokenStream) -> Result<TokenStream> {
     Ok(quote! { { #first } })
 }
 
-/// Parse `trees!(ctx, ...)` or `trees!(...)` — returns `Vec<Id>`.
+/// Parse `trees!(...)` — returns `Vec<Id>`.
 pub fn parse_trees_top(input: TokenStream) -> Result<TokenStream> {
     let mut tokens = input.into_iter().peekable();
-    let ctx = parse_ctx_or_implicit(&mut tokens);
+    let ctx = Ident::new(IMPLICIT_CTX, Span::call_site());
     let items = parse_direct_list(&mut tokens, &ctx)?;
     if let Some(tok) = tokens.next() {
         return Err(syn::Error::new_spanned(
@@ -388,6 +370,70 @@ pub fn parse_trees_top(input: TokenStream) -> Result<TokenStream> {
     })
 }
 
+pub fn parse_tree_at_top(input: TokenStream) -> Result<TokenStream> {
+    let mut tokens = input.into_iter().peekable();
+    let source = parse_argument(&mut tokens, "expected `,` after source node")?;
+    let ctx = Ident::new(IMPLICIT_CTX, Span::call_site());
+    let node = parse_direct_node(&mut tokens, &ctx, None)?;
+    if let Some(tok) = tokens.next() {
+        return Err(syn::Error::new_spanned(
+            tok,
+            "unexpected token after tree_at! template",
+        ));
+    }
+
+    Ok(quote! {
+        {
+            let __yeast_source: yeast::Id = { #source };
+            let __yeast_source_range = #ctx
+                .ast
+                .get_node(__yeast_source)
+                .and_then(|node| node.source_range());
+            let __yeast_node: yeast::Id = #node;
+            #ctx.set_node_source_range(__yeast_node, __yeast_source_range)
+        }
+    })
+}
+
+pub fn parse_tree_spanning_top(input: TokenStream) -> Result<TokenStream> {
+    let mut tokens = input.into_iter().peekable();
+    let sources = parse_argument(&mut tokens, "expected `,` after source nodes")?;
+    let ctx = Ident::new(IMPLICIT_CTX, Span::call_site());
+    let node = parse_direct_node(&mut tokens, &ctx, None)?;
+    if let Some(tok) = tokens.next() {
+        return Err(syn::Error::new_spanned(
+            tok,
+            "unexpected token after tree_spanning! template",
+        ));
+    }
+
+    Ok(quote! {
+        {
+            let __yeast_source_range = ::std::iter::IntoIterator::into_iter({ #sources })
+                .filter_map(|source: yeast::Id| {
+                    #ctx.ast.get_node(source).and_then(|node| node.source_range())
+                })
+                .reduce(yeast::Range::union);
+            let __yeast_node: yeast::Id = #node;
+            #ctx.set_node_source_range(__yeast_node, __yeast_source_range)
+        }
+    })
+}
+
+fn parse_argument(tokens: &mut Tokens, missing_comma: &str) -> Result<TokenStream> {
+    let mut argument = TokenStream::new();
+    while let Some(token) = tokens.next() {
+        if matches!(&token, TokenTree::Punct(p) if p.as_char() == ',') {
+            if argument.is_empty() {
+                return Err(syn::Error::new_spanned(token, "expected expression"));
+            }
+            return Ok(argument);
+        }
+        argument.extend([token]);
+    }
+    Err(syn::Error::new(Span::call_site(), missing_comma))
+}
+
 /// Parse a single node template and generate code that returns an `Id`.
 /// Handles: `(kind fields... children...)` and `{expr}`.
 ///

shared/yeast/doc/yeast.md

@@ -160,22 +160,21 @@ Templates construct new AST nodes using the `tree!` and `trees!` macros.
 All children in a template must be in named fields — output AST nodes are
 always fully fielded.
 
-When used inside a `rule!` macro, the context is implicit — no explicit
-`BuildCtx` argument is needed. When used standalone, they take a `BuildCtx`
-as the first argument:
+The macros use a `BuildCtx` binding named `ctx` from the surrounding scope.
+`rule!` provides this binding automatically; standalone uses must create it:
 
 ```rust
-// Inside rule! — implicit context, captures are Rust variables
+// Inside rule! — ctx is provided automatically, captures are Rust variables
 yeast::rule!(
     (assignment left: (_) @left right: (_) @right)
     =>
     (assignment left: {right} right: {left})
 );
 
-// Standalone — explicit context
+// Standalone — create a binding named ctx
 let mut user_ctx = ();
 let mut ctx = BuildCtx::new(ast, &captures, &mut user_ctx);
-let id = yeast::tree!(ctx,
+let id = yeast::tree!(
     (assignment
         left: {ctx.capture("lhs")}
         right: {ctx.capture("rhs")}
@@ -188,7 +187,7 @@ let id = yeast::tree!(ctx,
 `tree!(...)` returns a single node `Id`:
 
 ```rust
-yeast::tree!(ctx,
+yeast::tree!(
     (assignment
         left: {ctx.capture("lhs")}
         right: {ctx.capture("rhs")}
@@ -201,7 +200,7 @@ yeast::tree!(ctx,
 `trees!(...)` returns `Vec<Id>`:
 
 ```rust
-yeast::trees!(ctx,
+yeast::trees!(
     (assignment left: {tmp} right: {right})
     {body}
 )
@@ -262,7 +261,6 @@ rule!(
     =>
     synthetic_node {
         tree_at!(
-            ctx,
             source_node,
             (synthetic_node child: (nested value: {child}))
         )
@@ -282,7 +280,6 @@ rule!(
     =>
     synthetic_node {
         tree_spanning!(
-            ctx,
             [first, second],
             (synthetic_node child: {child})
         )
@@ -382,7 +379,7 @@ options uniformly:
     right: {rhs}               // a captured value (inside rule!)
 )
 
-yeast::trees!(ctx,
+yeast::trees!(
     (assignment left: {tmp} right: {right})
     {extra_nodes}              // splices a Vec<Id>
 )

shared/yeast/src/lib.rs

@@ -15,41 +15,7 @@ pub mod schema;
 mod visitor;
 
 pub use range::{Point, Range};
-pub use yeast_macros::{query, rule, rules, tree, trees};
-
-/// Build a single AST node whose root uses another node's source range.
-///
-/// Nested nodes in the template are built normally and derive their locations
-/// from their own children.
-#[macro_export]
-macro_rules! tree_at {
-    ($ctx:ident, $source:expr, ($($tree:tt)*)) => {{
-        let __yeast_source: $crate::Id = $source;
-        let __yeast_source_range = $ctx
-            .ast
-            .get_node(__yeast_source)
-            .and_then(|node| node.source_range());
-        let __yeast_node: $crate::Id = $crate::tree!($ctx, ($($tree)*));
-        $ctx.set_node_source_range(__yeast_node, __yeast_source_range)
-    }};
-}
-
-/// Build a single AST node whose root spans a collection of nodes.
-///
-/// Nested nodes in the template are built normally and derive their locations
-/// from their own children.
-#[macro_export]
-macro_rules! tree_spanning {
-    ($ctx:ident, $sources:expr, ($($tree:tt)*)) => {{
-        let __yeast_source_range = ::std::iter::IntoIterator::into_iter($sources)
-            .filter_map(|source: $crate::Id| {
-                $ctx.ast.get_node(source).and_then(|node| node.source_range())
-            })
-            .reduce($crate::Range::union);
-        let __yeast_node: $crate::Id = $crate::tree!($ctx, ($($tree)*));
-        $ctx.set_node_source_range(__yeast_node, __yeast_source_range)
-    }};
-}
+pub use yeast_macros::{query, rule, rules, tree, tree_at, tree_spanning, trees};
 
 use captures::Captures;
 use query::QueryNode;

shared/yeast/tests/test.rs

@@ -695,7 +695,7 @@ fn test_tree_builder() {
     // Swap left and right
     let mut user_ctx = ();
     let mut ctx = yeast::build::BuildCtx::new(&mut ast, &captures, &mut user_ctx);
-    let new_id = yeast::tree!(ctx,
+    let new_id = yeast::tree!(
         (program
             child: (assignment
                 left: {ctx.capture("right")}
@@ -723,8 +723,8 @@ fn build_optional_right(ast: &mut Ast, value: Option<yeast::Id>) -> (yeast::Id,
     let captures = yeast::captures::Captures::new();
     let mut user_ctx = ();
     let mut ctx = yeast::build::BuildCtx::new(ast, &captures, &mut user_ctx);
-    let left = yeast::tree!(ctx, (identifier "x"));
-    let root = yeast::tree!(ctx,
+    let left = yeast::tree!((identifier "x"));
+    let root = yeast::tree!(
         (assignment
             left: {left}
             right: (integer #{value})?
@@ -781,8 +781,8 @@ fn test_optional_field_propagates_through_nested_nodes() {
     // The absent value sits two levels below the `?`, so the whole
     // `left_assignment_list` subtree is abandoned along with it.
     let absent: Option<yeast::Id> = None;
-    let right = yeast::tree!(ctx, (integer "1"));
-    let root = yeast::tree!(ctx,
+    let right = yeast::tree!((integer "1"));
+    let root = yeast::tree!(
         (assignment
             left: (left_assignment_list child: (identifier #{absent}))?
             right: {right}
@@ -809,7 +809,7 @@ fn test_innermost_optional_field_catches_first() {
 
     // The inner `?` catches, so only `child` is dropped; `left` survives.
     let absent: Option<yeast::Id> = None;
-    let root = yeast::tree!(ctx,
+    let root = yeast::tree!(
         (assignment
             left: (left_assignment_list child: (identifier #{absent})?)?
         )
@@ -1782,7 +1782,7 @@ fn test_tree_at_assigns_capture_range_to_root_only() {
         ) @@source
         =>
         call {
-            let arguments = tree_at!(ctx, source, (argument_list argument: (integer "0")));
+            let arguments = tree_at!(source, (argument_list argument: (integer "0")));
             tree!((call method: {name} receiver: {recv} arguments: {arguments}))
         }
     );
@@ -1817,7 +1817,6 @@ fn test_tree_spanning_assigns_union_to_root_only() {
         =>
         call {
             let arguments = tree_spanning!(
-                ctx,
                 [recv, name],
                 (argument_list argument: (integer "0"))
             );