如何从板条箱/模块/功能派生代码？

Question

As far as I know, Rust supports #[derive] attribute to generate code at compile time from data structures. How can I generate code for whole crate, module or functions? The #[derive] attribute is not allowed here.

I want to generate a function which involves multiple items (structs/enums/functions) in the project.

For example, for given example module here

#[derive(MyAgg)]
mod AAA {
    struct BBB {}
    struct CCC {}
    fn ddd() {}
}

I want to produce this.

fn example1() {
    print("{:?}", AAA::BBB {});
    print("{:?}", AAA::CCC {});
    AAA::ddd()
}

This example doesn't make sense, but I think it delivers the point.

Answer 1

The #[derive] attribute is not allowed on modules, only on structs, enums and unions:

error: `derive` may only be applied to structs, enums and unions
 --> src/main.rs:1:1
  |
1 | #[derive(MyAgg)]
  | ^^^^^^^^^^^^^^^^

Playground

Further information on extending the #[derive] macro can be found in Procedural Macros (and custom Derive) in the Rust book.

However, you could create your own procedural macro. You may consult the RFC to understand proc-macros . It wouldn't hurt to also take a look at other crates like Serde or Derivative .

Answer 2

I found a workaround. You can spawn a Rust language parser and parse source code yourself.

First, add a dependency to Cargo.toml .

[dependencies]
syntex_syntax = "0.59.1"

And add these lines to src/main.rs .

extern crate syntex_syntax;

use std::path::*;
use syntex_syntax::parse::*;
use syntex_syntax::codemap::*;

fn main() {
    let f = file!(); // Get absolute path to this file.
    let p = Path::new(f);
    let m = FilePathMapping::empty();
    let s = ParseSess::new(m);
    let r = parse_crate_from_file(&p, &s);
    println!("{:?}", r);
}

Now you have a parsed AST.

---

Update

After several weeks of tries, I learned macro-expansion is done at syntax parsing stage. As it gets executed before type analysis stage, I cannot query fully resolved paths for each types, therefore stable referencing of multiple types from multiple module becomes very hard or impossible. Finally, I abandoned macro-based approach.