当前位置：首页 > news >正文

Rust编译时代码生成：从宏到过程宏的深度实践

news 2026/5/9 14:11:52

Rust编译时代码生成：从宏到过程宏的深度实践

引言

编译时代码生成是Rust的强大特性之一。通过宏和过程宏，我们可以在编译时生成代码，提高代码复用性和性能。

本文将深入探讨Rust中的编译时代码生成技术，包括声明式宏、过程宏、以及更高级的编译时计算。

一、声明式宏

1.1 基本宏定义

macro_rules! say_hello { () => { println!("Hello, World!"); }; } fn main() { say_hello!(); } macro_rules! create_function { ($func_name:ident) => { fn $func_name() { println!("Function {} called", stringify!($func_name)); } }; } create_function!(foo); create_function!(bar); fn main() { foo(); bar(); }

1.2 宏模式匹配

macro_rules! calculate { ($e:expr) => { { let val = $e; println!("{} = {}", stringify!($e), val); val } }; } macro_rules! vec_strs { ($($x:expr),*) => { vec![$($x.to_string()),*] }; } fn main() { calculate!(1 + 2 * 3); let strings = vec_strs!("a", "b", "c"); println!("{:?}", strings); }

1.3 递归宏

macro_rules! count_tts { () => { 0 }; ($_head:tt $($tail:tt)*) => { 1 + count_tts!($($tail)*) }; } macro_rules! nested_count { ($($e:expr),* $(,)*) => { <[usize; count_tts!($($e)*)]>::default() }; } fn main() { println!("Count: {}", count_tts!(a b c d e)); let arr = nested_count!(1, 2, 3); println!("Array size: {}", arr.len()); }

二、过程宏

2.1 派生宏

use proc_macro::TokenStream; use quote::quote; use syn; #[proc_macro_derive(HelloMacro)] pub fn hello_macro_derive(input: TokenStream) -> TokenStream { let ast = syn::parse_macro_input!(input as syn::DeriveInput); let name = &ast.ident; let expanded = quote! { impl HelloMacro for #name { fn hello_macro() { println!("Hello, Macro! My name is {}", stringify!(#name)); } } }; TokenStream::from(expanded) } trait HelloMacro { fn hello_macro(); } #[derive(HelloMacro)] struct Pancakes; fn main() { Pancakes::hello_macro(); }

2.2 属性宏

use proc_macro::TokenStream; use quote::quote; use syn::{parse_macro_input, AttributeArgs, ItemFn}; #[proc_macro_attribute] pub fn log(_args: TokenStream, input: TokenStream) -> TokenStream { let input = parse_macro_input!(input as ItemFn); let name = &input.sig.ident; let expanded = quote! { fn #name() { println!("Entering function: {}", stringify!(#name)); #input println!("Exiting function: {}", stringify!(#name)); } }; TokenStream::from(expanded) } #[log] fn my_function() { println!("Doing something..."); } fn main() { my_function(); }

2.3 函数式宏

use proc_macro::TokenStream; use quote::quote; use syn::parse_macro_input; #[proc_macro] pub fn sql(input: TokenStream) -> TokenStream { let input = parse_macro_input!(input as syn::LitStr); let sql_str = input.value(); let expanded = quote! { { use sqlx::query; query!(#sql_str) } }; TokenStream::from(expanded) } fn main() { let users = sql!("SELECT * FROM users WHERE id = 1").fetch_all(&pool).await?; }

三、编译时计算

3.1 const泛型

use std::marker::PhantomData; struct ArraySum<T, const N: usize>(PhantomData<T>); impl<T: std::ops::Add<Output = T> + Default + Copy, const N: usize> ArraySum<T, N> { const fn sum(arr: [T; N]) -> T { let mut result = T::default(); let mut i = 0; while i < N { result = result + arr[i]; i += 1; } result } } fn main() { const ARRAY: [i32; 5] = [1, 2, 3, 4, 5]; const SUM: i32 = ArraySum::<i32, 5>::sum(ARRAY); println!("Sum: {}", SUM); }

3.2 const fn

const fn fibonacci(n: u32) -> u32 { match n { 0 => 0, 1 => 1, _ => fibonacci(n - 1) + fibonacci(n - 2), } } const FIB_10: u32 = fibonacci(10); fn main() { println!("Fibonacci(10) = {}", FIB_10); } const fn parse_int(s: &str) -> Option<i32> { let mut result = 0; let mut sign = 1; let mut i = 0; let bytes = s.as_bytes(); if i < bytes.len() && bytes[i] == b'-' { sign = -1; i += 1; } while i < bytes.len() { let b = bytes[i]; if b < b'0' || b > b'9' { return None; } result = result * 10 + (b - b'0') as i32; i += 1; } Some(result * sign) } const PARSED: Option<i32> = parse_int("42");

3.3 类型级别编程

trait Nat { const VALUE: usize; } struct Zero; struct Succ<T: Nat>(T); impl Nat for Zero { const VALUE: usize = 0; } impl<T: Nat> Nat for Succ<T> { const VALUE: usize = T::VALUE + 1; } type One = Succ<Zero>; type Two = Succ<One>; type Three = Succ<Two>; fn main() { println!("Zero: {}", Zero::VALUE); println!("One: {}", One::VALUE); println!("Two: {}", Two::VALUE); println!("Three: {}", Three::VALUE); }

四、编译时代码生成实战

4.1 序列化宏

use proc_macro::TokenStream; use quote::quote; use syn::{parse_macro_input, DeriveInput, Fields}; #[proc_macro_derive(Serialize)] pub fn serialize_derive(input: TokenStream) -> TokenStream { let ast = parse_macro_input!(input as DeriveInput); let name = &ast.ident; let fields = match &ast.data { syn::Data::Struct(s) => &s.fields, _ => panic!("Only structs are supported"), }; let serialize_fields = match fields { Fields::Named(named) => { named.named.iter().map(|f| { let name = &f.ident; quote! { writer.write_field(stringify!(#name), &self.#name)?; } }) } Fields::Unnamed(unnamed) => { unnamed.unnamed.iter().enumerate().map(|(i, _)| { let index = syn::Index::from(i); quote! { writer.write_field(stringify!(#index), &self.#index)?; } }) } Fields::Unit => std::iter::empty(), }; let expanded = quote! { impl Serialize for #name { fn serialize<W: Writer>(&self, writer: &mut W) -> Result<(), W::Error> { writer.begin_struct(stringify!(#name))?; #(#serialize_fields)* writer.end_struct()?; Ok(()) } } }; TokenStream::from(expanded) }

4.2 SQL查询宏

use proc_macro::TokenStream; use quote::quote; use syn::parse_macro_input; #[proc_macro] pub fn query(input: TokenStream) -> TokenStream { let input = parse_macro_input!(input as syn::LitStr); let query_str = input.value(); let expanded = quote! { { struct QueryBuilder; impl QueryBuilder { fn build() -> String { #query_str.to_string() } } QueryBuilder::build() } }; TokenStream::from(expanded) } fn main() { let q = query!("SELECT * FROM users WHERE id = ?"); println!("Query: {}", q); }

五、宏的最佳实践

5.1 宏的组织

#[macro_export] macro_rules! my_crate_macro { () => { println!("This macro is exported"); }; } #[cfg(test)] mod tests { #[test] fn test_macro() { my_crate_macro!(); } }

5.2 宏的调试

#[macro_export] macro_rules! debug_macro { ($($tt:tt)*) => { { #[cfg(debug_assertions)] { println!("Macro input: {}", stringify!($($tt)*)); } $($tt)* } }; }