/// カスタム HashMap リテラルマクロ
macro_rules! map {
    // 空のマップ
    () => { std::collections::HashMap::new() };
 
    // key => value ペアを受け取る
    ( $( $key:expr => $value:expr ),+ $(,)? ) => {{
        let mut m = std::collections::HashMap::new();
        $( m.insert($key, $value); )+
        m
    }};
}
 
fn main() {
    let scores = map! {
        "Alice" => 95,
        "Bob"   => 82,
        "Carol" => 91,
    };
    println!("{:?}", scores);
    // {"Carol": 91, "Alice": 95, "Bob": 82}
}

macro_rules! explain {
    // アーム1: 空の入力
    () => {
        println!("引数なし");
    };
 
    // アーム2: 単一の式
    ($single:expr) => {
        println!("単一の式: {}", $single);
    };
 
    // アーム3: カンマ区切りの複数式
    ($first:expr, $($rest:expr),+) => {
        println!("最初: {}", $first);
        // 残りを再帰的に処理
        explain!($($rest),+);
    };
}
 
fn main() {
    explain!();             // "引数なし"
    explain!(42);           // "単一の式: 42"
    explain!(1, 2, 3);      // "最初: 1" → "最初: 2" → "単一の式: 3"
}

// $x:expr の後に続けられるのは => , ; のみ
macro_rules! ok_after_expr {
    ($e:expr, $f:expr) => { $e + $f };      // OK: カンマ
    // ($e:expr $f:expr) => { $e + $f };     // NG: 区切りなし
}
 
// $x:ty の後に続けられるのは => , = | ; : > >> [ { as where のみ
macro_rules! ok_after_ty {
    ($t:ty : $e:expr) => { let _: $t = $e; };  // OK: コロン
}
 
// $x:pat の後に続けられるのは => , = | if in のみ
macro_rules! ok_after_pat {
    ($p:pat => $e:expr) => {
        match some_val {
            $p => $e,
            _ => panic!(),
        }
    };
}
 
// $x:tt は何でもマッチするので後続制限なし
macro_rules! flexible {
    ($($t:tt)*) => { $($t)* };  // 何でもそのまま展開
}

/// コンパイル時にトークン数を数える
macro_rules! count {
    ()                          => { 0usize };
    ($head:tt $($tail:tt)*)     => { 1usize + count!($($tail)*) };
}
 
/// 固定サイズ配列を型安全に生成
macro_rules! fixed_vec {
    ( $( $elem:expr ),* $(,)? ) => {{
        const LEN: usize = count!($( { $elem } )*);
        let arr: [_; LEN] = [ $( $elem ),* ];
        arr
    }};
}
 
fn main() {
    let arr = fixed_vec![10, 20, 30];
    // arr は [i32; 3] 型
    assert_eq!(arr.len(), 3);
}

/// 数値型に対する共通トレイトを一括実装
trait Numeric {
    fn zero() -> Self;
    fn one() -> Self;
    fn is_positive(&self) -> bool;
}
 
macro_rules! impl_numeric {
    // 整数型用
    (int: $($t:ty),+ $(,)?) => {
        $(
            impl Numeric for $t {
                fn zero() -> Self { 0 }
                fn one() -> Self { 1 }
                fn is_positive(&self) -> bool { *self > 0 }
            }
        )+
    };
    // 浮動小数点型用
    (float: $($t:ty),+ $(,)?) => {
        $(
            impl Numeric for $t {
                fn zero() -> Self { 0.0 }
                fn one() -> Self { 1.0 }
                fn is_positive(&self) -> bool { *self > 0.0 }
            }
        )+
    };
}
 
impl_numeric!(int: i8, i16, i32, i64, i128, isize);
impl_numeric!(int: u8, u16, u32, u64, u128, usize);
impl_numeric!(float: f32, f64);
 
fn double<T: Numeric + std::ops::Add<Output = T> + Copy>(x: T) -> T {
    x + x
}
 
fn main() {
    assert_eq!(double(21i32), 42);
    assert_eq!(double(1.5f64), 3.0);
    assert!(42i32.is_positive());
    assert!(!(-1i32).is_positive());
}

/// HTML 風の構造を構築する DSL マクロ
macro_rules! html {
    // 終了条件: 空
    () => { String::new() };
 
    // テキストノード
    (text($text:expr) $($rest:tt)*) => {{
        let mut s = $text.to_string();
        s.push_str(&html!($($rest)*));
        s
    }};
 
    // 自閉じタグ <br/>
    ($tag:ident / $($rest:tt)*) => {{
        let mut s = format!("<{}/>", stringify!($tag));
        s.push_str(&html!($($rest)*));
        s
    }};
 
    // 開始タグ + 子要素 + 閉じタグ
    ($tag:ident { $($children:tt)* } $($rest:tt)*) => {{
        let mut s = format!("<{}>", stringify!($tag));
        s.push_str(&html!($($children)*));
        s.push_str(&format!("</{}>", stringify!($tag)));
        s.push_str(&html!($($rest)*));
        s
    }};
}
 
fn main() {
    let page = html! {
        div {
            h1 { text("Hello, World!") }
            p { text("Rust マクロで HTML を生成") }
            br /
            p { text("TT Muncher パターンの例") }
        }
    };
    println!("{}", page);
    // <div><h1>Hello, World!</h1><p>Rust マクロで HTML を生成</p><br/><p>TT Muncher パターンの例</p></div>
}

/// 簡易 JSON ビルダーマクロ
macro_rules! json {
    // null
    (null) => { JsonValue::Null };
 
    // boolean
    (true) => { JsonValue::Bool(true) };
    (false) => { JsonValue::Bool(false) };
 
    // 数値
    ($num:literal) => { JsonValue::Number($num as f64) };
 
    // 文字列
    ($s:literal) => { JsonValue::Str($s.to_string()) };
 
    // 配列
    ([ $($elem:tt),* $(,)? ]) => {
        JsonValue::Array(vec![ $(json!($elem)),* ])
    };
 
    // オブジェクト
    ({ $($key:literal : $value:tt),* $(,)? }) => {{
        let mut map = std::collections::BTreeMap::new();
        $(
            map.insert($key.to_string(), json!($value));
        )*
        JsonValue::Object(map)
    }};
}
 
#[derive(Debug, Clone, PartialEq)]
enum JsonValue {
    Null,
    Bool(bool),
    Number(f64),
    Str(String),
    Array(Vec<JsonValue>),
    Object(std::collections::BTreeMap<String, JsonValue>),
}
 
impl std::fmt::Display for JsonValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            JsonValue::Null => write!(f, "null"),
            JsonValue::Bool(b) => write!(f, "{}", b),
            JsonValue::Number(n) => write!(f, "{}", n),
            JsonValue::Str(s) => write!(f, "\"{}\"", s),
            JsonValue::Array(arr) => {
                write!(f, "[")?;
                for (i, v) in arr.iter().enumerate() {
                    if i > 0 { write!(f, ", ")?; }
                    write!(f, "{}", v)?;
                }
                write!(f, "]")
            }
            JsonValue::Object(map) => {
                write!(f, "{{")?;
                for (i, (k, v)) in map.iter().enumerate() {
                    if i > 0 { write!(f, ", ")?; }
                    write!(f, "\"{}\": {}", k, v)?;
                }
                write!(f, "}}")
            }
        }
    }
}
 
fn main() {
    let data = json!({
        "name": "Alice",
        "age": 30,
        "active": true,
        "scores": [95, 87, 92],
        "address": {
            "city": "Tokyo",
            "zip": "100-0001"
        }
    });
    println!("{}", data);
}

/// パラメタライズドテストを生成するマクロ
macro_rules! test_cases {
    (
        fn $test_name:ident($input:ident : $in_ty:ty) -> $out_ty:ty $body:block
        cases {
            $( $case_name:ident : $case_input:expr => $expected:expr ),+ $(,)?
        }
    ) => {
        // テスト対象の関数を生成
        fn $test_name($input: $in_ty) -> $out_ty $body
 
        // 各テストケースを個別のテスト関数として生成
        $(
            #[test]
            fn $case_name() {
                let result = $test_name($case_input);
                assert_eq!(result, $expected,
                    "テストケース '{}' が失敗: 入力={:?}, 期待={:?}, 実際={:?}",
                    stringify!($case_name), $case_input, $expected, result
                );
            }
        )+
    };
}
 
test_cases! {
    fn fizzbuzz(n: u32) -> String {
        match (n % 3, n % 5) {
            (0, 0) => "FizzBuzz".to_string(),
            (0, _) => "Fizz".to_string(),
            (_, 0) => "Buzz".to_string(),
            _ => n.to_string(),
        }
    }
    cases {
        test_one:       1  => "1".to_string(),
        test_three:     3  => "Fizz".to_string(),
        test_five:      5  => "Buzz".to_string(),
        test_fifteen:   15 => "FizzBuzz".to_string(),
        test_seven:     7  => "7".to_string(),
    }
}

// マクロのスコープルール:
// 1. macro_rules! は定義位置より後でのみ使用可能（テキスト順序に依存）
// 2. モジュール内で定義したマクロは #[macro_export] で公開可能
// 3. #[macro_export] されたマクロはクレートルートに配置される
 
// モジュール内でのマクロ定義と公開
mod utils {
    // このマクロはクレートルートに配置される
    #[macro_export]
    macro_rules! public_macro {
        () => { println!("公開マクロ") };
    }
 
    // macro_export なしだと同一モジュール内のみ
    macro_rules! private_macro {
        () => { println!("非公開マクロ") };
    }
 
    pub fn use_private() {
        private_macro!();
    }
}
 
// #[macro_use] による一括インポート（2015 edition スタイル）
// #[macro_use] extern crate some_crate;
 
// 2018+ edition では use でインポート可能
// use some_crate::public_macro;
 
// $crate を使った正しいパス参照
#[macro_export]
macro_rules! create_vec {
    ($($elem:expr),* $(,)?) => {
        {
            // $crate は定義元クレートを指す
            // 外部クレートから使われても正しく解決される
            let mut v = $crate::__internal::new_vec();
            $(v.push($elem);)*
            v
        }
    };
}
 
// マクロから参照される内部モジュール
#[doc(hidden)]
pub mod __internal {
    pub fn new_vec<T>() -> Vec<T> {
        Vec::new()
    }
}

# my-derive/Cargo.toml
[package]
name = "my-derive"
version = "0.1.0"
edition = "2021"
 
[lib]
proc-macro = true
 
[dependencies]
syn = { version = "2", features = ["full", "extra-traits"] }
quote = "1"
proc-macro2 = "1"
 
# テスト用（オプション）
[dev-dependencies]
trybuild = "1"   # コンパイルエラーのテスト

// my-derive/Cargo.toml
// [lib]
// proc-macro = true
//
// [dependencies]
// syn = { version = "2", features = ["full"] }
// quote = "1"
// proc-macro2 = "1"
 
// my-derive/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};
 
/// フィールド名とその値を表示する Describe トレイトを自動実装
#[proc_macro_derive(Describe)]
pub fn derive_describe(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
 
    let fields = if let syn::Data::Struct(data) = &ast.data {
        data.fields.iter().map(|f| {
            let fname = f.ident.as_ref().unwrap();
            quote! {
                write!(f, "  {}: {:?}\n", stringify!(#fname), &self.#fname)?;
            }
        }).collect::<Vec<_>>()
    } else {
        panic!("Describe は構造体のみ対応");
    };
 
    let expanded = quote! {
        impl std::fmt::Display for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                writeln!(f, "{}:", stringify!(#name))?;
                #( #fields )*
                Ok(())
            }
        }
    };
 
    TokenStream::from(expanded)
}
 
// my-app/src/main.rs
// use my_derive::Describe;
//
// #[derive(Debug, Describe)]
// struct Config {
//     host: String,
//     port: u16,
//     debug: bool,
// }
//
// fn main() {
//     let cfg = Config {
//         host: "localhost".into(),
//         port: 8080,
//         debug: true,
//     };
//     println!("{}", cfg);
//     // Config:
//     //   host: "localhost"
//     //   port: 8080
//     //   debug: true
// }

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields};
 
/// 列挙体のバリアント名を文字列として返す EnumName トレイトを自動実装
#[proc_macro_derive(EnumName)]
pub fn derive_enum_name(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
 
    let variants = match &ast.data {
        Data::Enum(data) => &data.variants,
        _ => {
            return syn::Error::new_spanned(
                &ast.ident,
                "EnumName は列挙体にのみ適用できます",
            )
            .to_compile_error()
            .into();
        }
    };
 
    // 各バリアントに対するマッチアームを生成
    let match_arms = variants.iter().map(|v| {
        let variant_name = &v.ident;
        let name_str = variant_name.to_string();
        match &v.fields {
            Fields::Unit => {
                quote! { #name::#variant_name => #name_str }
            }
            Fields::Unnamed(_) => {
                quote! { #name::#variant_name(..) => #name_str }
            }
            Fields::Named(_) => {
                quote! { #name::#variant_name { .. } => #name_str }
            }
        }
    });
 
    // all_names メソッド用のバリアント名リスト
    let all_names = variants.iter().map(|v| {
        let name_str = v.ident.to_string();
        quote! { #name_str }
    });
 
    let expanded = quote! {
        impl #name {
            /// このバリアントの名前を文字列として返す
            pub fn variant_name(&self) -> &'static str {
                match self {
                    #(#match_arms,)*
                }
            }
 
            /// 全バリアント名のスライスを返す
            pub fn all_variant_names() -> &'static [&'static str] {
                &[#(#all_names,)*]
            }
        }
    };
 
    TokenStream::from(expanded)
}
 
// 使用例:
// #[derive(EnumName)]
// enum Color {
//     Red,
//     Green,
//     Blue,
//     Custom(u8, u8, u8),
//     Named { name: String },
// }
//
// fn main() {
//     let c = Color::Custom(255, 0, 128);
//     println!("{}", c.variant_name());  // "Custom"
//     println!("{:?}", Color::all_variant_names());
//     // ["Red", "Green", "Blue", "Custom", "Named"]
// }

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields, Lit, Meta, NestedMeta};
 
/// フィールドのバリデーションを自動生成する Validate derive
/// ヘルパー属性 #[validate(...)] をサポート
#[proc_macro_derive(Validate, attributes(validate))]
pub fn derive_validate(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
 
    let fields = match &ast.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(f) => &f.named,
            _ => panic!("名前付きフィールドのみ対応"),
        },
        _ => panic!("構造体のみ対応"),
    };
 
    let validations = fields.iter().filter_map(|field| {
        let field_name = field.ident.as_ref().unwrap();
 
        // #[validate(...)] 属性を探す
        let validate_attrs: Vec<_> = field.attrs.iter()
            .filter(|attr| attr.path().is_ident("validate"))
            .collect();
 
        if validate_attrs.is_empty() {
            return None;
        }
 
        let mut checks = Vec::new();
 
        for attr in &validate_attrs {
            // 属性の内容を解析（簡易版）
            // 実際の実装では syn のパース機能を使う
            let meta = attr.parse_args::<Meta>().ok()?;
 
            match &meta {
                Meta::NameValue(nv) if nv.path.is_ident("min_len") => {
                    if let Lit::Int(lit) = &nv.lit {
                        let min: usize = lit.base10_parse().unwrap();
                        checks.push(quote! {
                            if self.#field_name.len() < #min {
                                errors.push(format!(
                                    "'{}' の長さが最小値 {} 未満です（実際: {}）",
                                    stringify!(#field_name), #min, self.#field_name.len()
                                ));
                            }
                        });
                    }
                }
                Meta::Path(path) if path.is_ident("non_empty") => {
                    checks.push(quote! {
                        if self.#field_name.is_empty() {
                            errors.push(format!(
                                "'{}' は空であってはなりません",
                                stringify!(#field_name)
                            ));
                        }
                    });
                }
                _ => {}
            }
        }
 
        Some(quote! { #(#checks)* })
    });
 
    let expanded = quote! {
        impl #name {
            pub fn validate(&self) -> Result<(), Vec<String>> {
                let mut errors = Vec::new();
                #(#validations)*
                if errors.is_empty() {
                    Ok(())
                } else {
                    Err(errors)
                }
            }
        }
    };
 
    TokenStream::from(expanded)
}
 
// 使用例:
// #[derive(Validate)]
// struct User {
//     #[validate(non_empty)]
//     #[validate(min_len = 3)]
//     name: String,
//
//     #[validate(non_empty)]
//     email: String,
// }

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn};
 
/// 関数の実行時間を計測する属性マクロ
#[proc_macro_attribute]
pub fn measure_time(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let func = parse_macro_input!(item as ItemFn);
    let name = &func.sig.ident;
    let block = &func.block;
    let sig = &func.sig;
    let vis = &func.vis;
    let attrs = &func.attrs;
 
    let expanded = quote! {
        #(#attrs)*
        #vis #sig {
            let __start = std::time::Instant::now();
            let __result = (|| #block)();
            let __elapsed = __start.elapsed();
            eprintln!("[measure] {} took {:?}", stringify!(#name), __elapsed);
            __result
        }
    };
 
    TokenStream::from(expanded)
}
 
// 使用例:
// #[measure_time]
// fn heavy_computation() -> u64 {
//     (0..1_000_000).sum()
// }

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, ItemFn, LitInt};
 
/// リトライ回数を指定する属性マクロ
/// #[retry(3)] のように使用
#[proc_macro_attribute]
pub fn retry(attr: TokenStream, item: TokenStream) -> TokenStream {
    let max_retries = parse_macro_input!(attr as LitInt);
    let max_retries_val: usize = max_retries.base10_parse().unwrap();
    let func = parse_macro_input!(item as ItemFn);
 
    let name = &func.sig.ident;
    let vis = &func.vis;
    let inputs = &func.sig.inputs;
    let output = &func.sig.output;
    let block = &func.block;
    let attrs = &func.attrs;
 
    // 戻り値が Result 型であることを前提とする
    let expanded = quote! {
        #(#attrs)*
        #vis fn #name(#inputs) #output {
            let mut __attempts = 0usize;
            loop {
                __attempts += 1;
                let __result = (|| #block)();
                match __result {
                    Ok(val) => return Ok(val),
                    Err(e) => {
                        if __attempts >= #max_retries_val {
                            eprintln!(
                                "[retry] {} が {} 回のリトライ後も失敗: {:?}",
                                stringify!(#name), #max_retries_val, e
                            );
                            return Err(e);
                        }
                        eprintln!(
                            "[retry] {} 試行 {}/{} が失敗、リトライします...",
                            stringify!(#name), __attempts, #max_retries_val
                        );
                        std::thread::sleep(std::time::Duration::from_millis(
                            100 * __attempts as u64
                        ));
                    }
                }
            }
        }
    };
 
    TokenStream::from(expanded)
}
 
// 使用例:
// #[retry(3)]
// fn fetch_data(url: &str) -> Result<String, Box<dyn std::error::Error>> {
//     let response = reqwest::blocking::get(url)?;
//     Ok(response.text()?)
// }

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, LitStr};
 
/// SQL文をコンパイル時に検証する（簡易版）
#[proc_macro]
pub fn checked_sql(input: TokenStream) -> TokenStream {
    let sql_lit = parse_macro_input!(input as LitStr);
    let sql = sql_lit.value();
 
    // 簡易バリデーション
    let upper = sql.to_uppercase();
    if !upper.starts_with("SELECT")
        && !upper.starts_with("INSERT")
        && !upper.starts_with("UPDATE")
        && !upper.starts_with("DELETE")
    {
        return syn::Error::new(
            sql_lit.span(),
            "SQL は SELECT/INSERT/UPDATE/DELETE で始まる必要があります",
        )
        .to_compile_error()
        .into();
    }
 
    let expanded = quote! { #sql };
    TokenStream::from(expanded)
}
 
// 使用例:
// let query = checked_sql!("SELECT * FROM users WHERE id = $1");
// let bad   = checked_sql!("DROP TABLE users"); // コンパイルエラー!

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse::{Parse, ParseStream}, Ident, LitStr, Token, punctuated::Punctuated};
 
/// ルーティングテーブルを定義する function-like マクロ
/// routes! {
///     GET "/users"        => list_users,
///     POST "/users"       => create_user,
///     GET "/users/{id}"   => get_user,
/// }
 
struct Route {
    method: Ident,
    path: LitStr,
    handler: Ident,
}
 
impl Parse for Route {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let method: Ident = input.parse()?;
        let path: LitStr = input.parse()?;
        input.parse::<Token![=>]>()?;
        let handler: Ident = input.parse()?;
        Ok(Route { method, path, handler })
    }
}
 
struct Routes {
    routes: Punctuated<Route, Token![,]>,
}
 
impl Parse for Routes {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let routes = Punctuated::parse_terminated(input)?;
        Ok(Routes { routes })
    }
}
 
#[proc_macro]
pub fn routes(input: TokenStream) -> TokenStream {
    let routes = syn::parse_macro_input!(input as Routes);
 
    let route_entries = routes.routes.iter().map(|r| {
        let method_str = r.method.to_string();
        let path = &r.path;
        let handler = &r.handler;
        quote! {
            Router::route(#method_str, #path, #handler)
        }
    });
 
    let expanded = quote! {
        {
            let mut router = Router::new();
            #(router.add(#route_entries);)*
            router
        }
    };
 
    TokenStream::from(expanded)
}

# インストール
cargo install cargo-expand
 
# 特定の関数だけ展開
cargo expand --lib -- some_module::some_fn
 
# テストコードも含めて展開
cargo expand --tests
 
# 特定 derive だけ確認
cargo expand --lib | grep -A 50 "impl Display"
 
# 特定のアイテムだけ展開
cargo expand --lib ::my_module::MyStruct

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};
 
#[proc_macro_derive(MyDerive)]
pub fn my_derive(input: TokenStream) -> TokenStream {
    // デバッグ1: 入力トークンストリームを標準エラーに出力
    eprintln!("=== Input TokenStream ===");
    eprintln!("{}", input.to_string());
 
    let ast = parse_macro_input!(input as DeriveInput);
 
    // デバッグ2: パースされた AST を確認
    // syn の "extra-traits" feature が必要
    eprintln!("=== Parsed AST ===");
    eprintln!("{:#?}", ast);
 
    let name = &ast.ident;
    let expanded = quote! {
        impl #name {
            pub fn hello() {
                println!("Hello from {}", stringify!(#name));
            }
        }
    };
 
    // デバッグ3: 生成されるコードを確認
    eprintln!("=== Generated Code ===");
    eprintln!("{}", expanded.to_string());
 
    TokenStream::from(expanded)
}

// tests/ui.rs
#[test]
fn ui_tests() {
    let t = trybuild::TestCases::new();
    // コンパイルが成功するべきテスト
    t.pass("tests/ui/pass_*.rs");
    // コンパイルが失敗するべきテスト（エラーメッセージも検証）
    t.compile_fail("tests/ui/fail_*.rs");
}
 
// tests/ui/pass_basic.rs
// use my_derive::EnumName;
//
// #[derive(EnumName)]
// enum Color {
//     Red,
//     Green,
//     Blue,
// }
//
// fn main() {
//     let c = Color::Red;
//     assert_eq!(c.variant_name(), "Red");
// }
 
// tests/ui/fail_struct.rs
// use my_derive::EnumName;
//
// #[derive(EnumName)]
// struct NotAnEnum {  // エラー: EnumName は列挙体にのみ適用できます
//     field: i32,
// }
//
// fn main() {}
 
// tests/ui/fail_struct.stderr（期待されるエラーメッセージ）
// error: EnumName は列挙体にのみ適用できます
//   --> tests/ui/fail_struct.rs:4:8
//    |
//  4 | struct NotAnEnum {
//    |        ^^^^^^^^^^

// nightly コンパイラが必要
#![feature(trace_macros)]
 
macro_rules! factorial {
    (1) => { 1u64 };
    ($n:literal) => { $n as u64 * factorial!($n - 1) };
}
 
fn main() {
    trace_macros!(true);
    let result = factorial!(5);
    trace_macros!(false);
    println!("5! = {}", result);
}
 
// コンパイル時の出力:
// note: trace_macro
//  --> src/main.rs:9:18
//   |
// 9 |     let result = factorial!(5);
//   |                  ^^^^^^^^^^^^
//   |
//   = note: expanding `factorial! { 5 }`
//   = note: to `5 as u64 * factorial!(5 - 1)`
//   = note: expanding `factorial! { 5 - 1 }`
//   ...

use quote::quote;
use syn::Ident;
use proc_macro2::Span;
 
// 単一変数の補間
let name = Ident::new("MyStruct", Span::call_site());
let tokens = quote! { struct #name {} };
// → struct MyStruct {}
 
// 繰り返しの補間
let fields = vec!["x", "y", "z"];
let field_idents: Vec<_> = fields.iter()
    .map(|f| Ident::new(f, Span::call_site()))
    .collect();
let tokens = quote! {
    struct Point {
        #(pub #field_idents: f64,)*
    }
};
// → struct Point { pub x: f64, pub y: f64, pub z: f64, }
 
// 区切り文字付き繰り返し
let values = vec![1i32, 2, 3];
let tokens = quote! {
    let sum = #(#values)+*;
};
// → let sum = 1 + 2 + 3;
 
// ネストされた繰り返し
let methods = vec![("get_x", "x"), ("get_y", "y")];
let method_tokens: Vec<_> = methods.iter().map(|(method, field)| {
    let method_ident = Ident::new(method, Span::call_site());
    let field_ident = Ident::new(field, Span::call_site());
    quote! {
        pub fn #method_ident(&self) -> f64 {
            self.#field_ident
        }
    }
}).collect();
 
let tokens = quote! {
    impl Point {
        #(#method_tokens)*
    }
};
 
// format_ident! で識別子を動的に生成
let prefix = "get";
let field = "name";
let getter = quote::format_ident!("{}_{}", prefix, field);
// → get_name

// NG: 関数やジェネリクスで十分な処理をマクロにする
macro_rules! add_numbers {
    ($a:expr, $b:expr) => { $a + $b };
}
 
// OK: 通常の関数で十分
fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}
 
// マクロが適切な場面:
// - 型に跨る繰り返しパターン (impl Trait for A, B, C...)
// - コンパイル時計算/検証
// - DSL (ドメイン固有言語)
// - ボイラープレート削減 (derive 対応できない場合)

// NG: 外側の変数名に依存するマクロ
macro_rules! bad_log {
    ($msg:expr) => {
        // logger が呼び出し元スコープに存在する前提 — 危険!
        logger.log($msg);
    };
}
 
// OK: 必要な依存は引数で明示
macro_rules! good_log {
    ($logger:expr, $msg:expr) => {
        $logger.log($msg);
    };
}
 
// OK: 手続き的マクロで衛生的な変数名を生成
// quote! {
//     let __internal_logger = get_logger();
//     __internal_logger.log(#msg);
// }

// NG: $val が複数回評価される
macro_rules! bad_max {
    ($a:expr, $b:expr) => {
        if $a > $b { $a } else { $b }
    };
}
 
// 問題: 副作用のある式が2回実行される
// bad_max!(expensive_call(), another_call());
// → if expensive_call() > another_call() { expensive_call() } else { another_call() }
// expensive_call() が2回呼ばれる可能性がある!
 
// OK: 一度変数に束縛する
macro_rules! good_max {
    ($a:expr, $b:expr) => {{
        let __a = $a;
        let __b = $b;
        if __a > __b { __a } else { __b }
    }};
}

// NG: 暗黙の型変換を行うマクロ
macro_rules! bad_convert {
    ($val:expr) => {
        $val as i64  // 情報の損失が見えない
    };
}
 
// OK: 明示的な型変換関数
fn safe_convert(val: u32) -> i64 {
    i64::from(val)  // From トレイトで安全に変換
}
 
// OK: TryFrom で失敗を明示
fn try_convert(val: i64) -> Result<u32, std::num::TryFromIntError> {
    u32::try_from(val)
}

// NG: 数百行のマクロ — 読めない、デバッグできない、IDEサポートなし
 
// OK: マクロは薄いラッパーにとどめ、実装はヘルパー関数に委譲
macro_rules! register_handler {
    ($name:ident, $method:expr, $path:expr) => {
        // マクロはグルーコードだけ
        fn $name(registry: &mut Registry) {
            // 実際のロジックは通常の関数に委譲
            __register_handler_impl(registry, $method, $path, $name::handler);
        }
    };
}
 
// ヘルパー関数は通常のRustコードなのでIDEサポートも効く
fn __register_handler_impl(
    registry: &mut Registry,
    method: &str,
    path: &str,
    handler: fn(&Request) -> Response,
) {
    registry.add_route(method, path, handler);
}

// builder-derive/src/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Data, Fields};
 
#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    let builder_name = syn::Ident::new(
        &format!("{}Builder", name),
        name.span(),
    );
 
    let fields = match &ast.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(f) => &f.named,
            _ => panic!("名前付きフィールドのみ対応"),
        },
        _ => panic!("構造体のみ対応"),
    };
 
    // Builder のフィールド (全て Option<T>)
    let builder_fields = fields.iter().map(|f| {
        let name = &f.ident;
        let ty = &f.ty;
        quote! { #name: Option<#ty> }
    });
 
    // setter メソッド
    let setters = fields.iter().map(|f| {
        let name = &f.ident;
        let ty = &f.ty;
        quote! {
            pub fn #name(mut self, val: #ty) -> Self {
                self.#name = Some(val);
                self
            }
        }
    });
 
    // build メソッドのフィールド取り出し
    let build_fields = fields.iter().map(|f| {
        let name = &f.ident;
        quote! {
            #name: self.#name.ok_or(
                format!("フィールド '{}' が未設定", stringify!(#name))
            )?
        }
    });
 
    // Builder のデフォルト値 (全て None)
    let none_fields = fields.iter().map(|f| {
        let name = &f.ident;
        quote! { #name: None }
    });
 
    let expanded = quote! {
        pub struct #builder_name {
            #( #builder_fields, )*
        }
 
        impl #name {
            pub fn builder() -> #builder_name {
                #builder_name {
                    #( #none_fields, )*
                }
            }
        }
 
        impl #builder_name {
            #( #setters )*
 
            pub fn build(self) -> Result<#name, String> {
                Ok(#name {
                    #( #build_fields, )*
                })
            }
        }
    };
 
    TokenStream::from(expanded)
}

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Data, Fields, Lit, Meta};
 
/// 拡張版 Builder — デフォルト値とバリデーションをサポート
/// #[builder(default = "value")] でデフォルト値を指定
/// #[builder(required)] で必須フィールドを明示
#[proc_macro_derive(ExtBuilder, attributes(builder))]
pub fn derive_ext_builder(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;
    let builder_name = quote::format_ident!("{}Builder", name);
 
    let fields = match &ast.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(f) => &f.named,
            _ => return err(name, "名前付きフィールドのみ対応"),
        },
        _ => return err(name, "構造体のみ対応"),
    };
 
    let mut builder_field_defs = Vec::new();
    let mut setter_defs = Vec::new();
    let mut build_assigns = Vec::new();
    let mut default_assigns = Vec::new();
 
    for field in fields.iter() {
        let field_name = field.ident.as_ref().unwrap();
        let field_ty = &field.ty;
 
        // #[builder(...)] 属性を解析
        let mut has_default = false;
        let mut default_expr = None;
 
        for attr in &field.attrs {
            if !attr.path().is_ident("builder") {
                continue;
            }
            // 属性の中身を解析（簡易版）
            // 実際には syn::parse を使ってもっと堅牢にする
            if let Ok(Meta::NameValue(nv)) = attr.parse_args::<Meta>() {
                if nv.path.is_ident("default") {
                    has_default = true;
                    if let Lit::Str(s) = &nv.lit {
                        default_expr = Some(s.value());
                    }
                }
            }
        }
 
        builder_field_defs.push(quote! {
            #field_name: Option<#field_ty>
        });
 
        setter_defs.push(quote! {
            pub fn #field_name(mut self, val: #field_ty) -> Self {
                self.#field_name = Some(val);
                self
            }
        });
 
        if has_default {
            if let Some(expr_str) = default_expr {
                let expr: proc_macro2::TokenStream = expr_str.parse().unwrap();
                build_assigns.push(quote! {
                    #field_name: self.#field_name.unwrap_or_else(|| #expr)
                });
            } else {
                build_assigns.push(quote! {
                    #field_name: self.#field_name.unwrap_or_default()
                });
            }
        } else {
            build_assigns.push(quote! {
                #field_name: self.#field_name.ok_or_else(||
                    format!("必須フィールド '{}' が未設定です", stringify!(#field_name))
                )?
            });
        }
 
        default_assigns.push(quote! { #field_name: None });
    }
 
    let expanded = quote! {
        pub struct #builder_name {
            #(#builder_field_defs,)*
        }
 
        impl #name {
            pub fn builder() -> #builder_name {
                #builder_name {
                    #(#default_assigns,)*
                }
            }
        }
 
        impl #builder_name {
            #(#setter_defs)*
 
            pub fn build(self) -> Result<#name, String> {
                Ok(#name {
                    #(#build_assigns,)*
                })
            }
        }
    };
 
    TokenStream::from(expanded)
}
 
fn err(ident: &syn::Ident, msg: &str) -> TokenStream {
    syn::Error::new_spanned(ident, msg)
        .to_compile_error()
        .into()
}
 
// 使用例:
// #[derive(ExtBuilder)]
// struct ServerConfig {
//     host: String,                           // 必須
//     port: u16,                              // 必須
//     #[builder(default = "30")]
//     timeout_secs: u64,                      // デフォルト: 30
//     #[builder(default = "true")]
//     tls_enabled: bool,                      // デフォルト: true
//     #[builder(default = "String::from(\"INFO\")")]
//     log_level: String,                      // デフォルト: "INFO"
// }
//
// fn main() {
//     let config = ServerConfig::builder()
//         .host("0.0.0.0".to_string())
//         .port(8080)
//         // timeout_secs, tls_enabled, log_level はデフォルト値が使われる
//         .build()
//         .unwrap();
// }

/// トレイトオブジェクトの動的ディスパッチを静的ディスパッチに変換する
/// enum_dispatch! パターンの簡易実装
macro_rules! enum_dispatch {
    (
        trait $trait_name:ident {
            $(fn $method:ident(&self $(, $arg:ident : $arg_ty:ty)*) -> $ret:ty;)*
        }
 
        enum $enum_name:ident {
            $($variant:ident($inner:ty)),+ $(,)?
        }
    ) => {
        // トレイト定義
        trait $trait_name {
            $(fn $method(&self $(, $arg: $arg_ty)*) -> $ret;)*
        }
 
        // 列挙体定義
        enum $enum_name {
            $($variant($inner),)+
        }
 
        // From 実装
        $(
            impl From<$inner> for $enum_name {
                fn from(v: $inner) -> Self {
                    $enum_name::$variant(v)
                }
            }
        )+
 
        // トレイト実装（match で各バリアントに委譲）
        impl $trait_name for $enum_name {
            $(
                fn $method(&self $(, $arg: $arg_ty)*) -> $ret {
                    match self {
                        $($enum_name::$variant(inner) => inner.$method($($arg),*),)+
                    }
                }
            )*
        }
    };
}
 
// 使用例
enum_dispatch! {
    trait Shape {
        fn area(&self) -> f64;
        fn name(&self) -> &'static str;
    }
 
    enum AnyShape {
        Circle(Circle),
        Rectangle(Rectangle),
        Triangle(Triangle),
    }
}
 
struct Circle { radius: f64 }
impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.radius * self.radius }
    fn name(&self) -> &'static str { "Circle" }
}
 
struct Rectangle { width: f64, height: f64 }
impl Shape for Rectangle {
    fn area(&self) -> f64 { self.width * self.height }
    fn name(&self) -> &'static str { "Rectangle" }
}
 
struct Triangle { base: f64, height: f64 }
impl Shape for Triangle {
    fn area(&self) -> f64 { 0.5 * self.base * self.height }
    fn name(&self) -> &'static str { "Triangle" }
}
 
fn print_area(shape: &AnyShape) {
    // dyn Shape ではなく enum match で静的ディスパッチ
    println!("{}: area = {:.2}", shape.name(), shape.area());
}
 
fn main() {
    let shapes: Vec<AnyShape> = vec![
        Circle { radius: 5.0 }.into(),
        Rectangle { width: 4.0, height: 6.0 }.into(),
        Triangle { base: 3.0, height: 8.0 }.into(),
    ];
 
    for shape in &shapes {
        print_area(shape);
    }
    // Circle: area = 78.54
    // Rectangle: area = 24.00
    // Triangle: area = 12.00
}

/// 型状態パターンを自動生成するマクロ
/// コンパイル時に不正な状態遷移を防止する
macro_rules! state_machine {
    (
        machine $machine:ident {
            states: [ $($state:ident),+ $(,)? ],
            transitions: [
                $($from:ident -> $to:ident : $event:ident ($($arg:ident : $arg_ty:ty),*) ),+ $(,)?
            ]
        }
    ) => {
        // 状態型（ゼロサイズ型）
        $(
            #[derive(Debug)]
            pub struct $state;
        )+
 
        // 状態マシン本体
        #[derive(Debug)]
        pub struct $machine<State> {
            _state: std::marker::PhantomData<State>,
            // 実際にはここにデータフィールドが入る
            data: String,
        }
 
        // 初期状態の生成
        impl $machine<$($state)?> {
            // ここは最初の状態に対してのみ
        }
 
        // 各遷移メソッドを生成
        $(
            impl $machine<$from> {
                pub fn $event(self $(, $arg: $arg_ty)*) -> $machine<$to> {
                    println!("[state] {} -> {} (event: {})",
                        stringify!($from),
                        stringify!($to),
                        stringify!($event)
                    );
                    $machine {
                        _state: std::marker::PhantomData,
                        data: self.data,
                    }
                }
            }
        )+
    };
}
 
// 使用例: HTTP リクエストの状態マシン
state_machine! {
    machine HttpRequest {
        states: [Created, HeadersSent, BodySent, Complete],
        transitions: [
            Created -> HeadersSent : send_headers(headers: Vec<(String, String)>),
            HeadersSent -> BodySent : send_body(body: Vec<u8>),
            BodySent -> Complete : finish(),
        ]
    }
}
 
impl HttpRequest<Created> {
    pub fn new(url: &str) -> Self {
        HttpRequest {
            _state: std::marker::PhantomData,
            data: url.to_string(),
        }
    }
}
 
fn main() {
    let req = HttpRequest::new("https://example.com");
    let req = req.send_headers(vec![
        ("Content-Type".into(), "application/json".into()),
    ]);
    let req = req.send_body(b"{}".to_vec());
    let _req = req.finish();
 
    // コンパイルエラー: Created 状態から直接 send_body は呼べない
    // let req = HttpRequest::new("https://example.com");
    // let req = req.send_body(b"{}".to_vec()); // ERROR!
}

/// ビットフラグ型を自動生成するマクロ
macro_rules! bitflags {
    (
        $(#[$outer:meta])*
        $vis:vis struct $name:ident : $repr:ty {
            $(
                $(#[$inner:meta])*
                const $flag:ident = $value:expr;
            )*
        }
    ) => {
        $(#[$outer])*
        #[derive(Clone, Copy, PartialEq, Eq, Hash)]
        $vis struct $name {
            bits: $repr,
        }
 
        impl $name {
            $(
                $(#[$inner])*
                pub const $flag: $name = $name { bits: $value };
            )*
 
            /// 空のフラグセット
            pub const fn empty() -> Self {
                $name { bits: 0 }
            }
 
            /// 全フラグが立ったセット
            pub const fn all() -> Self {
                $name { bits: $( $value )|* }
            }
 
            /// 指定フラグが含まれているか
            pub const fn contains(self, other: Self) -> bool {
                (self.bits & other.bits) == other.bits
            }
 
            /// フラグが空かどうか
            pub const fn is_empty(self) -> bool {
                self.bits == 0
            }
 
            /// 生のビット値を取得
            pub const fn bits(self) -> $repr {
                self.bits
            }
 
            /// フラグを追加
            pub fn insert(&mut self, other: Self) {
                self.bits |= other.bits;
            }
 
            /// フラグを除去
            pub fn remove(&mut self, other: Self) {
                self.bits &= !other.bits;
            }
 
            /// フラグをトグル
            pub fn toggle(&mut self, other: Self) {
                self.bits ^= other.bits;
            }
        }
 
        impl std::ops::BitOr for $name {
            type Output = Self;
            fn bitor(self, rhs: Self) -> Self {
                $name { bits: self.bits | rhs.bits }
            }
        }
 
        impl std::ops::BitAnd for $name {
            type Output = Self;
            fn bitand(self, rhs: Self) -> Self {
                $name { bits: self.bits & rhs.bits }
            }
        }
 
        impl std::ops::BitOrAssign for $name {
            fn bitor_assign(&mut self, rhs: Self) {
                self.bits |= rhs.bits;
            }
        }
 
        impl std::ops::Not for $name {
            type Output = Self;
            fn not(self) -> Self {
                $name { bits: !self.bits & Self::all().bits }
            }
        }
 
        impl std::fmt::Debug for $name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                let mut first = true;
                write!(f, "{}(", stringify!($name))?;
                $(
                    if self.contains($name::$flag) {
                        if !first { write!(f, " | ")?; }
                        write!(f, stringify!($flag))?;
                        first = false;
                    }
                )*
                if first {
                    write!(f, "empty")?;
                }
                write!(f, ")")
            }
        }
    };
}
 
// 使用例
bitflags! {
    /// ファイルのアクセス権限
    pub struct Permissions: u32 {
        /// 読み取り権限
        const READ    = 0b001;
        /// 書き込み権限
        const WRITE   = 0b010;
        /// 実行権限
        const EXECUTE = 0b100;
    }
}
 
fn main() {
    let mut perms = Permissions::READ | Permissions::WRITE;
    println!("{:?}", perms);
    // Permissions(READ | WRITE)
 
    assert!(perms.contains(Permissions::READ));
    assert!(!perms.contains(Permissions::EXECUTE));
 
    perms.insert(Permissions::EXECUTE);
    println!("{:?}", perms);
    // Permissions(READ | WRITE | EXECUTE)
 
    perms.remove(Permissions::WRITE);
    println!("{:?}", perms);
    // Permissions(READ | EXECUTE)
 
    let readonly = !Permissions::WRITE & Permissions::all();
    println!("{:?}", readonly);
    // Permissions(READ | EXECUTE)
}