初次尝试 Rust Macro 宏

#[macro_export]
macro_rules! my_vec {
    () => {
        Vec::new()
    };
    ($($x:expr),*) => {
        {
            let mut temp_vec = Vec::new();
            $(
                temp_vec.push($x);
            )*
            temp_vec
        }
    };
}

#[macro_export]
macro_rules! my_vec {
    ($x:expr) => {
        {
            let mut temp_vec = Vec::new();
            temp_vec.push($x);
            temp_vec
        }
    };
}
fn main() {
    let x = 1;
    let v = my_vec!(x);
    println!("{:?}", v); // [1]
}

pub trait Hello {
    fn hello(&self);
}

#[proc_macro_derive(HelloMacro)]
pub fn hello_derive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;

    // 生成 impl 代码
    TokenStream::from(quote! {
        impl Hello for #name {
            fn hello(&self) {
                println!("Hello, I'm a {}!", stringify!(#name));
            }
        }
    })
}

#[proc_macro_derive(HelloMacro2)]
pub fn hello_derive2(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    quote! {
        impl #name {
            pub fn hello(&self) {
                println!("Hello from {}", stringify!(#name));
            }
        }
    }
    .into()
}

struct Person;

impl Hello for Person {
    fn hello(&self) {
        println!("Hello, I'm a Person!");
    }
}

#[derive(HelloMacro)]
struct Animal;

#[derive(HelloMacro2)]
struct MyStruct;

#[derive(HelloMacro)]
struct MyStruct2;

fn main() {
    let person = Person;
    person.hello();
    let animal = Animal;
    animal.hello();
    let my_struct = MyStruct;
    my_struct.hello();

    // 测试多态情况下，宏是否有用
    let v: Vec<Box<dyn Hello>> = vec![Box::new(Person), Box::new(Animal), Box::new(MyStruct2)];
    // 下面代码编译报错，因为 MyStruct2 没有实现 Hello trait
    // let v: Vec<Box<dyn Hello>> = vec![Box::new(Person), Box::new(Animal), Box::new(MyStruct)];
    for item in v {
        item.hello();
    }
}

#[proc_macro_attribute]
pub fn timeit(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // `_attr` 是属性本身的 TokenStream，这里我们不需要参数，所以忽略它。
    // `item` 是属性所附加的项（在这里是函数）的 TokenStream。

    // 1. 解析输入的函数代码
    // parse_macro_input! 帮助我们解析 TokenStream 为 syn 库中的结构体
    // ItemFn 代表一个函数定义
    let input_fn = parse_macro_input!(item as ItemFn);

    // 2. 提取函数的各个部分
    let function_name = &input_fn.sig.ident; // 函数名 (Ident)
    let signature = &input_fn.sig; // 函数签名 (Signature)
    let body = &input_fn.block; // 函数体 (Block)
    let attributes = &input_fn.attrs; // 函数上的其他属性 (Vec<Attribute>)
    let visibility = &input_fn.vis; // 函数的可见性 (Visibility)

    // 将函数名转换为字符串，以便在 println! 中使用
    let function_name_str = function_name.to_string();

    // 3. 构建新的代码块
    // quote! 宏用于方便地生成 TokenStream
    let expanded = quote! {
        // 保留原始的属性（如 #[allow(...)] 等）
        #(#attributes)*
        // 保留原始的可见性、签名（包括 fn async 等关键字和参数/返回值）
        #visibility #signature {
            // 在函数体执行前记录开始时间
            let start_time = std::time::Instant::now();

            // 执行原始的函数体，并捕获其返回值
            // 将原始函数体放在一个块 {} 中，确保其内部变量不泄露，并捕获返回值
            let result = #body;

            // 等待一秒钟
            std::thread::sleep(std::time::Duration::from_secs(3));

            // 在函数体执行后记录结束时间并计算时长
            let duration = start_time.elapsed();

            // 打印函数名和执行时间
            // 使用 #function_name_str （字符串字面量） 代替 #[function_name] (Ident)
            println!("Function '{}' executed in {:?}", #function_name_str, duration);

            // 返回原始函数体的结果
            result
        }
    };

    // 4. 将生成的代码块转换回 TokenStream 并返回
    expanded.into()
}