yeast: Remove now-redundant tree_at! and tree_spanning! macros

Author: tausbn

shared/yeast-macros/src/lib.rs

@@ -127,38 +127,6 @@ 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

shared/yeast-macros/src/parse.rs

@@ -1,9 +1,5 @@
 use proc_macro2::{Span, TokenStream, TokenTree};
 use quote::quote;
-use syn::{
-    parse::{Parse, ParseStream},
-    Expr, Token,
-};
 
 type Result<T> = std::result::Result<T, syn::Error>;
 
@@ -28,47 +24,6 @@ pub fn parse_trees_top(input: TokenStream) -> Result<TokenStream> {
     Ok(crate::ast::Template::lower_list(&templates))
 }
 
-pub fn parse_tree_at_top(input: TokenStream) -> Result<TokenStream> {
-    let LocatedTreeInput { source, template } = syn::parse2(input)?;
-    let template = crate::template_parse::parse_template(template)?;
-    let node = template.lower_root();
-    let ctx = syn::Ident::new("ctx", Span::call_site());
-
-    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 LocatedTreeInput {
-        source: sources,
-        template,
-    } = syn::parse2(input)?;
-    let template = crate::template_parse::parse_template(template)?;
-    let node = template.lower_root();
-    let ctx = syn::Ident::new("ctx", Span::call_site());
-
-    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)
-        }
-    })
-}
-
 pub fn parse_rule_top(input: TokenStream) -> Result<TokenStream> {
     Ok(crate::rule_parse::parse_rule(input)?.lower())
 }
@@ -127,20 +82,6 @@ pub fn parse_rules_top(input: TokenStream) -> Result<TokenStream> {
     })
 }
 
-struct LocatedTreeInput {
-    source: Expr,
-    template: TokenStream,
-}
-
-impl Parse for LocatedTreeInput {
-    fn parse(input: ParseStream<'_>) -> syn::Result<Self> {
-        let source = input.parse()?;
-        input.parse::<Token![,]>()?;
-        let template = input.parse()?;
-        Ok(Self { source, template })
-    }
-}
-
 struct NamedString {
     value: String,
 }

shared/yeast/doc/yeast.md

@@ -297,45 +297,8 @@ leaf nodes:
 (identifier "synthetic" location: {source_node})
 ```
 
-The following macros can be used to explicitly set the location associated
-with a newly-created node. They assign a location only to the root of their
-template; nested nodes still derive their locations normally.
-
-`tree_at!` assigns the range of one captured input node to the template root:
-
-```rust
-rule!(
-    (wrapper
-        source: (_) @source_node
-        child: (_) @child)
-    =>
-    synthetic_node {
-        tree_at!(
-            source_node,
-            (synthetic_node child: (nested value: {child}))
-        )
-    }
-)
-```
-
-`tree_spanning!` assigns the smallest range containing several captured input
-nodes:
-
-```rust
-rule!(
-    (wrapper
-        first: (_) @first
-        second: (_) @second
-        child: (_) @child)
-    =>
-    synthetic_node {
-        tree_spanning!(
-            [first, second],
-            (synthetic_node child: {child})
-        )
-    }
-)
-```
+The override applies only to the node carrying the `location` field; nested
+nodes still derive their locations normally.
 
 For input fields whose leading or trailing syntax should never belong to rule
 results, configure them once with

shared/yeast/src/lib.rs

@@ -15,7 +15,7 @@ pub mod schema;
 mod visitor;
 
 pub use range::{Point, Range};
-pub use yeast_macros::{query, rule, rules, tree, tree_at, tree_spanning, trees};
+pub use yeast_macros::{query, rule, rules, tree, trees};
 
 use captures::Captures;
 use query::QueryNode;

shared/yeast/tests/test.rs

@@ -1841,17 +1841,19 @@ fn test_explicit_recursive_translation_keeps_nested_rule_location() {
     assert_eq!(identifier.byte_range(), 4..7);
 }
 
-/// `tree_at!` assigns the captured node's range only to the template root.
+/// A `location` field assigns the captured node's range only to its node.
 #[test]
-fn test_tree_at_assigns_capture_range_to_root_only() {
+fn test_location_field_assigns_capture_range_to_node_only() {
     let rule: Rule = rule!(
         (call
             method: (identifier) @name
             receiver: (identifier) @recv
         ) @@source
         =>
         call {
-            let arguments = tree_at!(source, (argument_list argument: (integer "0")));
+            let arguments = tree!((argument_list
+                argument: (integer "0")
+                location: {source}));
             tree!((call method: {name} receiver: {recv} arguments: {arguments}))
         }
     );
@@ -1874,21 +1876,20 @@ fn test_tree_at_assigns_capture_range_to_root_only() {
     assert_eq!(integer.byte_range(), 0..0);
 }
 
-/// `tree_spanning!` assigns the union of the captured node ranges only to the
-/// template root.
+/// Multiple `location` fields assign their union only to their node.
 #[test]
-fn test_tree_spanning_assigns_union_to_root_only() {
+fn test_multiple_location_fields_assign_union_to_node_only() {
     let rule: Rule = rule!(
         (call
             method: (identifier) @name
             receiver: (identifier) @recv
         )
         =>
         call {
-            let arguments = tree_spanning!(
-                [recv, name],
-                (argument_list argument: (integer "0"))
-            );
+            let arguments = tree!((argument_list
+                argument: (integer "0")
+                location: {recv}
+                location: {name}));
             tree!((call method: {name} receiver: {recv} arguments: {arguments}))
         }
     );