False positive "unused variable" with recursive macro

rust-analyzer version: 0.4.1676-standalone

rustc version: rustc 1.72.0 (5680fa18f 2023-08-23)

relevant settings: Not sure of any relevant settings. I typically use "rust-analyzer.procMacro.enable": true in the settings, but this doesn't seem to affect the issue.

I'm getting false positive "unused variable" warnings from rust-analyzer in the following recursive macro:

// Simplified example:
struct Node;

impl Node {
    fn new() -> Self {
        Node {}
    }
    fn add_child(&self, _child: Node) {
        unimplemented!()
    }
}

macro_rules! assemble_tree {
    ($base:expr => { $($other:tt)* }) => {
        assemble_tree!( @recurse, $base, $($other)*)
    };

    // Patterns for 'child' syntax
    (@recurse, $base:expr, $child:expr $(,)?) => {
        $base.add_child($child)
    };
    (@recurse, $base:expr, $child:expr, $($other:tt)+) => {
        $base.add_child($child);
        assemble_tree!( @recurse, $base, $($other)*)
    };

    // Patterns for 'child => { ... }' syntax
    (@recurse, $base:expr, $child:expr => { $($children:tt)* } $(,)?) => {
        let temp = $child;
        assemble_tree!( temp => { $($children)* });
        $base.add_child(temp)
    };
    (@recurse, $base:expr, $child:expr => { $($children:tt)* }, $($other:tt)+) => {
        let temp = $child;
        assemble_tree!( temp => { $($children)* });
        $base.add_child(temp);
        assemble_tree!( @recurse, $base, $($other)*)
    };
}

fn main() {
    // No warnings in this case:
    assemble_tree!(
        Node::new() => {
            Node::new() => {
                Node::new()
            }
        }
    );

    // But "unused variable" warnings in this case:
    assemble_tree!(
        Node::new() => {
            Node::new() => {
                Node::new() => {
                    Node::new()
                }
            }
        }
    );
}

I don't think there is an unused variable here, cargo build and cargo clippy don't complain about anything.

On first glance it looks like the issue has to do with the depth of the assembled tree, i.e., the depth of the macro recursion, because usages that only involve up to 3 level do not produce a warning, but usages that go 4 levels deep start to produce the warning.

Reproduce the report's simplified recursive assemble_tree! macro, especially the four-level case, and compare rust-analyzer's unused-variable diagnostics with cargo build and cargo clippy. Done means the recursive macro no longer produces a false unused-variable warning while valid diagnostics remain.