CodeBlanks Logo Icon CodeBlanks
Login Register

attribute macro

Write an attribute macro with #[proc_macro_attribute].

Attribute macros

Attribute macros take the whole item they mark and put whatever they want in its place. They also take the attribute's own arguments:

#[proc_macro_attribute]
pub fn olcumle(arg: TokenStream, oge: TokenStream) -> TokenStream {
    let mut f = syn::parse_macro_input!(oge as syn::ItemFn);
    let ad = f.sig.ident.to_string();
    let govde = &f.block;
    f.block = syn::parse_quote!({
        println!("{} çağrıldı", #ad);
        #govde
    });
    quote::quote!(#f).into()
}

// usage:
#[olcumle]
fn kare(x: i32) -> i32 { x * x }

#[tokio::main], things like #[test], and #[get("/")] in web frameworks are attribute macros.

Wrapping with macro_rules!

We can do the same transformation with macro_rules! by passing the function to the macro as an argument:

macro_rules! olcumle {
    (fn $ad:ident($($arg:ident : $tur:ty),*) -> $don:ty $govde:block) => {
        fn $ad($($arg: $tur),*) -> $don {
            println!("{} çağrıldı", stringify!($ad));
            $govde
        }
    };
}

olcumle! {
    fn kare(x: i32) -> i32 { x * x }
}

$govde:block captures the braced body as a single piece.

Practice Report the call

Write the olcumle! macro above and define the function fn kare(x: i32) -> i32 { x * x } with it. In main, print the result of kare(4).

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
macro_rules! olcumle {
    (fn $ad:ident($($arg:ident : $tur:ty),*) -> $don:ty $govde:block) => {
        fn $ad($($arg: $tur),*) -> $don {
            println!("{} çağrıldı", stringify!($ad));
            $govde
        }
    };
}

olcumle! {
    fn kare(x: i32) -> i32 {
        x * x
    }
}

fn main() {
    let s = kare(4);
    println!("{}", s);
}

Expected output

kare çağrıldı
16

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What happens if an attribute macro takes the function but doesn't put it in the output?

  • It warns
  • The function disappears from the program Correct answer
  • The compiler adds it back
  • Panic

Explanation: An attribute macro fully replaces the item; preserving the original item is the macro's responsibility.

2 Capture the body

Question 
(fn $ad:ident($($arg:ident : $tur:ty),*) -> $don:ty $govde:____) => { .. }
Answer 
(fn $ad:ident($($arg:ident : $tur:ty),*) -> $don:ty $govde:block) => { .. }

Explanation: The block fragment matches a braced block.

3 Attribute and role

Term Meaning
#[proc_macro_attribute] Defines an attribute macro
arg: TokenStream Attribute arguments
oge: TokenStream The marked item
syn::ItemFn Function tree

All lessons in Advanced

1 async/await

  1. async fn
  2. await
  3. Future trait
  4. async block
  5. Pin
  6. Summary - async/await

2 Tokio

  1. Tokio runtime
  2. spawn
  3. tokio::sync
  4. tokio::fs
  5. select!
  6. Summary - Tokio

3 Concurrency

  1. thread::spawn
  2. Mutex<T>
  3. RwLock<T>
  4. Arc<T>
  5. Send and Sync
  6. Summary - Concurrency

4 Channels

  1. mpsc channel
  2. send and recv
  3. Multiple producers
  4. try_recv
  5. tokio::sync::mpsc
  6. Summary - Channels

5 Project: Chat server

  1. TCP listener
  2. Client thread
  3. Channel messaging
  4. Broadcast
  5. Arc<Mutex> state

6 Unsafe Rust

  1. unsafe block
  2. Raw pointers
  3. unsafe fn
  4. static mut
  5. FFI call
  6. Summary - Unsafe Rust

7 FFI

  1. extern block
  2. #[repr(C)]
  3. CString and CStr
  4. Callback
  5. Drop and cleanup
  6. Summary - FFI

8 Declarative macros

  1. macro_rules!
  2. Repetitions
  3. Types
  4. Macro hygiene
  5. Inspecting println!
  6. Summary - Declarative macros

9 Procedural macros

  1. proc_macro crate
  2. derive macro
  3. attribute macro
  4. syn and quote
  5. TokenStream
  6. Summary - Procedural macros

10 Trait objects

  1. dyn Trait
  2. Box<dyn Trait>
  3. Static vs dynamic dispatch
  4. Object safety
  5. &dyn Trait
  6. Summary - Trait objects

11 Advanced traits

  1. Associated type
  2. Associated constant
  3. GAT
  4. Supertrait
  5. Newtype pattern
  6. Summary - Advanced traits

12 Const generics

  1. [T; N]
  2. const fn
  3. Const trait bound
  4. Min_const_generics
  5. Array and slice
  6. Summary - Const generics

13 Advanced patterns

  1. Struct patterns
  2. Destructuring
  3. @ binding
  4. Guard
  5. Binding modes
  6. Summary - Advanced patterns

14 Advanced final

  1. Async web server
  2. ThreadPool
  3. derive macro
  4. FFI wrapper