Procedural Macros в Rust

1// proc-macro crate
2use proc_macro::TokenStream;
3use quote::quote;
4use syn::{parse_macro_input, DeriveInput};
5
6#[proc_macro_derive(HelloMacro)]
7pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
8    let ast = parse_macro_input!(input as DeriveInput);
9    let name = &ast.ident;
10
11    let gen = quote! {
12        impl HelloMacro for #name {
13            fn hello_macro() {
14                println!("Hello from {}!", stringify!(#name));
15            }
16        }
17    };
18
19    gen.into()
20}
21
22// Trait для derive
23pub trait HelloMacro {
24    fn hello_macro();
25}

1use my_macros::HelloMacro;
2
3#[derive(HelloMacro)]
4struct Pancakes;
5
6fn main() {
7    Pancakes::hello_macro();  // Hello from Pancakes!
8}

1use proc_macro::TokenStream;
2use quote::quote;
3use syn::{parse_macro_input, ItemFn};
4
5#[proc_macro_attribute]
6pub fn route(attr: TokenStream, item: TokenStream) -> TokenStream {
7    let input = parse_macro_input!(item as ItemFn);
8    let name = &input.sig.ident;
9    let body = &input.block;
10    let attrs = attr.to_string();
11
12    let gen = quote! {
13        fn #name() {
14            println!("Route: {}", #attrs);
15            #body
16        }
17    };
18
19    gen.into()
20}

1use my_macros::route;
2
3#[route("GET /users")]
4fn get_users() {
5    println!("Getting users");
6}

1use proc_macro::TokenStream;
2use quote::quote;
3use syn::{parse_macro_input, LitStr};
4
5#[proc_macro]
6pub fn sql(input: TokenStream) -> TokenStream {
7    let query = parse_macro_input!(input as LitStr);
8    let query_str = query.value();
9
10    let gen = quote! {
11        {
12            let query = #query_str;
13            println!("Executing SQL: {}", query);
14            // Выполнение запроса
15        }
16    };
17
18    gen.into()
19}

1use my_macros::sql;
2
3fn main() {
4    sql!("SELECT * FROM users WHERE id = 1");
5}

1use syn::{parse_macro_input, DeriveInput, Data, Fields};
2
3#[proc_macro_derive(Builder)]
4pub fn builder_derive(input: TokenStream) -> TokenStream {
5    let input = parse_macro_input!(input as DeriveInput);
6    let name = &input.ident;
7
8    // Получение полей
9    let fields = match &input.data {
10        Data::Struct(data) => match &data.fields {
11            Fields::Named(fields) => &fields.named,
12            _ => panic!("Only named fields supported"),
13        },
14        _ => panic!("Only structs supported"),
15    };
16
17    // Генерация кода
18    let builder_name = format_ident!("{}Builder", name);
19    let field_names: Vec<_> = fields.iter().map(|f| &f.ident).collect();
20    let field_types: Vec<_> = fields.iter().map(|f| &f.ty).collect();
21
22    let gen = quote! {
23        struct #builder_name {
24            #(#field_names: Option<#field_types>,)*
25        }
26
27        impl #builder_name {
28            fn new() -> Self {
29                Self {
30                    #(#field_names: None,)*
31                }
32            }
33
34            #(
35                fn #field_names(mut self, value: #field_types) -> Self {
36                    self.#field_names = Some(value);
37                    self
38                }
39            )*
40        }
41    };
42
43    gen.into()
44}

1// serde derive macro
2#[derive(Serialize, Deserialize, Debug)]
3struct User {
4    name: String,
5    age: u32,
6    email: String,
7}
8
9// Автоматическая реализация
10// impl Serialize for User { ... }
11// impl Deserialize<'de> for User { ... }

1#[derive(Builder)]
2struct Config {
3    host: String,
4    port: u16,
5    max_connections: u32,
6}
7
8// Генерируется:
9// ConfigBuilder с методами host(), port(), max_connections()
10// build() метод для создания Config

1// tests/macro_tests.rs
2use my_macros::HelloMacro;
3
4#[derive(HelloMacro)]
5struct TestStruct;
6
7#[test]
8fn test_hello_macro() {
9    // Проверка что макрос генерирует правильный код
10    let output = TestStruct::hello_macro();
11    assert!(output.contains("TestStruct"));
12}

1use proc_macro::TokenStream;
2use syn::parse_macro_input;
3
4#[proc_macro]
5pub fn my_macro(input: TokenStream) -> TokenStream {
6    let _ = parse_macro_input!(input as syn::Expr)
7        .map_err(|e| {
8            // Генерация ошибки компиляции
9            syn::Error::new(e.span(), "Invalid expression")
10                .to_compile_error()
11        });
12
13    // ...
14}

1// Плохо: сложная логика в macro
2#[proc_macro_derive(BadMacro)]
3pub fn bad_derive(input: TokenStream) -> TokenStream {
4    // Сотни строк кода
5}
6
7// Хорошо: простой delegation
8#[proc_macro_derive(GoodMacro)]
9pub fn good_derive(input: TokenStream) -> TokenStream {
10    let ast = parse_macro_input!(input as DeriveInput);
11    generate_impl(ast).into()
12}

1/// Добавляет метод hello_macro() для структуры
2///
3/// # Пример
4/// ```
5/// #[derive(HelloMacro)]
6/// struct Foo;
7///
8/// Foo::hello_macro(); // Prints "Hello from Foo!"
9/// ```
10#[proc_macro_derive(HelloMacro)]
11pub fn hello_macro_derive(input: TokenStream) -> TokenStream {
12    // ...
13}