syn VS quote

[2] https://github.com/dtolnay/syn/issues/782

It looks to me like you are trying to make a syntax tree generic over arities. I suggest you take a look at the Expr enum in syn, its variant structs, and the ast_enum_of_structs_impl macro, which is a macro that implements a trait over different Expr variants with different fields.

Rust makes this project easy by providing the syn crate (parsing and formatting) and WASM (for interactivity). Source code lives at https://github.com/CarlKCarlK/rust-ast-explorer. Contributions welcome.

Perhaps there should, but if you look at the commit history you'll see that syn is maintained almost entirely by dtolnay (https://github.com/dtolnay/syn/graphs/contributors). Furthermore, with Rust continually adding new syntax that needs to be supported, syn can't be easy to maintain and most of the effort probably goes into making it work at all rather than optimisations.

A surprising source of slow compile times can be declarative macros in Rust [0].

I believe the core of the problem is that it has to reparse the code to pattern match for the macro.

One egregious patter is tt-munchers [1] where your macro is implemented recursively, requiring it to reparse the source on each call [2].

In one of my projects, someone decided to wrap a lot of core functions in simple macros (ie nt tt-munchers) to simplify the signatures. Unlike most macros which are used occasionally and have small inputs, this was a lot of input. When I refactored the code, I suspect dropping the macros is the reason CI times were cut in half and a clean `cargo check` went from 3s to 0.5s.

[0]: https://nnethercote.github.io/2022/04/12/how-to-speed-up-the...

[1]: https://veykril.github.io/tlborm/decl-macros/patterns/tt-mun...

[2]: https://github.com/dtolnay/quote/blob/31c3be473d0457e29c4f47...

In the build.rs, call your code generation function (probably in a separate crate added in build-dependencies). This function will read your input files, and use something like quote to generate code.

Or you can pair them with crates like syn, and quote for quasi-quoting, and then it's easy to make transformations on the AST of Rust input code. A lot of libraries do this for code-generation and hiding away a lot of complexity (example wasm-bindgen).