geez 0.1.0

//! **geez** — Global Error Embedding Zero-cost.
//!
//! Declarative error enums with thiserror-like attributes.
//! Zero dependencies. Pure `macro_rules!`.
//!
//! ```
//! use geez::geez;
//!
//! geez! {
//!     pub enum AppError {
//!         #[from]
//!         Io(std::io::Error),
//!
//!         #[error("bad status {0}")]
//!         Status(u16),
//!
//!         NotFound => "not found",
//!     }
//! }
//!
//! fn open_config() -> Result<()> {
//!     std::fs::File::open("missing.txt")?;
//!     Ok(())
//! }
//! ```

/// Build an error enum with `Display`, `Error`, optional `From` impls, and a `Result` alias.
///
/// See the crate README for the attribute cheat sheet.
#[macro_export]
macro_rules! geez {
    (
        $(#[$enum_meta:meta])*
        $vis:vis enum $name:ident {
            $($body:tt)*
        }
    ) => {
        $crate::geez!(@collect
            enum_meta: [$(#[$enum_meta])*]
            vis: [$vis]
            name: $name
            out: []
            rest: [$($body)*]
        );
    };

    // ── collect ────────────────────────────────────────────────────

    (@collect
        enum_meta: $enum_meta:tt
        vis: $vis:tt
        name: $name:ident
        out: [$($out:tt)*]
        rest: []
    ) => {
        $crate::geez!(@emit
            enum_meta: $enum_meta
            vis: $vis
            name: $name
            variants: [$($out)*]
        );
    };

    (@collect
        enum_meta: $enum_meta:tt
        vis: $vis:tt
        name: $name:ident
        out: [$($out:tt)*]
        rest: [, $($rest:tt)*]
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta
            vis: $vis
            name: $name
            out: [$($out)*]
            rest: [$($rest)*]
        );
    };

    (@collect
        enum_meta: $enum_meta:tt
        vis: $vis:tt
        name: $name:ident
        out: [$($out:tt)*]
        rest: [$($rest:tt)+]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta
            vis: $vis
            name: $name
            out: [$($out)*]
            keep: []
            from: N
            transparent: N
            source: N
            error: []
            rest: [$($rest)+]
        );
    };

    // ── classify attrs ─────────────────────────────────────────────

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: [$($keep:tt)*] from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [#[from] $($rest:tt)*]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: [$($keep)*] from: Y transparent: $transparent
            source: $source error: $error
            rest: [$($rest)*]
        );
    };

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: [$($keep:tt)*] from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [#[transparent] $($rest:tt)*]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: [$($keep)*] from: $from transparent: Y
            source: $source error: $error
            rest: [$($rest)*]
        );
    };

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: [$($keep:tt)*] from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [#[source] $($rest:tt)*]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: [$($keep)*] from: $from transparent: $transparent
            source: Y error: $error
            rest: [$($rest)*]
        );
    };

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: [$($keep:tt)*] from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [#[error($fmt:literal)] $($rest:tt)*]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: [$($keep)*] from: $from transparent: $transparent
            source: $source error: [$fmt]
            rest: [$($rest)*]
        );
    };

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: [$($keep:tt)*] from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [#[$other:meta] $($rest:tt)*]
    ) => {
        $crate::geez!(@classify
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: [$($keep)* #[$other]] from: $from transparent: $transparent
            source: $source error: $error
            rest: [$($rest)*]
        );
    };

    (@classify
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt
        rest: [$variant:ident $($rest:tt)*]
    ) => {
        $crate::geez!(@after_name
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent
            source: $source error: $error
            variant: $variant
            rest: [$($rest)*]
        );
    };

    // ── name + fields + => ─────────────────────────────────────────

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [($($fields:ty),+ $(,)?) => $arrow:literal , $($rest:tt)*]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [$arrow] variant: $variant
            fields: [$($fields),+] rest: [$($rest)*]
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [($($fields:ty),+ $(,)?) => $arrow:literal]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [$arrow] variant: $variant
            fields: [$($fields),+] rest: []
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [($($fields:ty),+ $(,)?) , $($rest:tt)*]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [] variant: $variant
            fields: [$($fields),+] rest: [$($rest)*]
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [($($fields:ty),+ $(,)?)]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [] variant: $variant
            fields: [$($fields),+] rest: []
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [=> $arrow:literal , $($rest:tt)*]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [$arrow] variant: $variant
            fields: [] rest: [$($rest)*]
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [=> $arrow:literal]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [$arrow] variant: $variant
            fields: [] rest: []
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: [, $($rest:tt)*]
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [] variant: $variant
            fields: [] rest: [$($rest)*]
        );
    };

    (@after_name
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident
        source: $source:ident error: $error:tt variant: $variant:ident
        rest: []
    ) => {
        $crate::geez!(@check_flags
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            error: $error arrow: [] variant: $variant
            fields: [] rest: []
        );
    };

    // ── validate flags ─────────────────────────────────────────────

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: Y transparent: Y source: $source:ident
        error: $error:tt arrow: $arrow:tt variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` cannot combine #[from] and #[transparent]"
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: Y transparent: $transparent:ident source: Y
        error: $error:tt arrow: $arrow:tt variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` cannot combine #[from] and #[source]"
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: Y source: Y
        error: $error:tt arrow: $arrow:tt variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` cannot combine #[transparent] and #[source]"
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: Y source: $source:ident
        error: [$($fmt:literal)+] arrow: $arrow:tt variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` is #[transparent]; drop #[error(...)]"
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: Y source: $source:ident
        error: [] arrow: [$($arrow:literal)+] variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` is #[transparent]; drop => \"...\""
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        error: [$($efmt:literal)+] arrow: [$($afmt:literal)+] variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` has both #[error(...)] and => \"...\"; pick one"
        ));
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        error: [$fmt:literal] arrow: [] variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        $crate::geez!(@pack
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            fmt: [$fmt] variant: $variant fields: $fields rest: $rest
        );
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        error: [] arrow: [$fmt:literal] variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        $crate::geez!(@pack
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            fmt: [$fmt] variant: $variant fields: $fields rest: $rest
        );
    };

    (@check_flags
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        error: [] arrow: [] variant: $variant:ident
        fields: $fields:tt rest: $rest:tt
    ) => {
        $crate::geez!(@pack
            enum_meta: $enum_meta vis: $vis name: $name out: $out
            keep: $keep from: $from transparent: $transparent source: $source
            fmt: [] variant: $variant fields: $fields rest: $rest
        );
    };

    // ── pack variant record (patterns inlined; macros only in expr/item position)

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident fields: [] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant]
                disp: [$name::$variant]
                src: [$name::$variant]
                args: []
                fields: []
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident fields: [$t0:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0)]
                disp: [$name::$variant(_0)]
                src: [$name::$variant(_0)]
                args: [_0]
                fields: [$t0]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident fields: [$t0:ty, $t1:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1)]
                disp: [$name::$variant(_0, _1)]
                src: [$name::$variant(..)]
                args: [_0, _1]
                fields: [$t0, $t1]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident fields: [$t0:ty, $t1:ty, $t2:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2)]
                disp: [$name::$variant(_0, _1, _2)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2]
                fields: [$t0, $t1, $t2]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident
        fields: [$t0:ty, $t1:ty, $t2:ty, $t3:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2, $t3)]
                disp: [$name::$variant(_0, _1, _2, _3)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2, _3]
                fields: [$t0, $t1, $t2, $t3]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident
        fields: [$t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2, $t3, $t4)]
                disp: [$name::$variant(_0, _1, _2, _3, _4)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2, _3, _4]
                fields: [$t0, $t1, $t2, $t3, $t4]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident
        fields: [$t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2, $t3, $t4, $t5)]
                disp: [$name::$variant(_0, _1, _2, _3, _4, _5)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2, _3, _4, _5]
                fields: [$t0, $t1, $t2, $t3, $t4, $t5]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident
        fields: [$t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2, $t3, $t4, $t5, $t6)]
                disp: [$name::$variant(_0, _1, _2, _3, _4, _5, _6)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2, _3, _4, _5, _6]
                fields: [$t0, $t1, $t2, $t3, $t4, $t5, $t6]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: [$($out:tt)*]
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident
        fields: [$t0:ty, $t1:ty, $t2:ty, $t3:ty, $t4:ty, $t5:ty, $t6:ty, $t7:ty] rest: $rest:tt
    ) => {
        $crate::geez!(@collect
            enum_meta: $enum_meta vis: $vis name: $name
            out: [$($out)* {
                keep: $keep
                from: $from
                transparent: $transparent
                source: $source
                fmt: $fmt
                variant: $variant
                def: [$variant($t0, $t1, $t2, $t3, $t4, $t5, $t6, $t7)]
                disp: [$name::$variant(_0, _1, _2, _3, _4, _5, _6, _7)]
                src: [$name::$variant(..)]
                args: [_0, _1, _2, _3, _4, _5, _6, _7]
                fields: [$t0, $t1, $t2, $t3, $t4, $t5, $t6, $t7]
            }]
            rest: $rest
        );
    };

    (@pack
        enum_meta: $enum_meta:tt vis: $vis:tt name: $name:ident out: $out:tt
        keep: $keep:tt from: $from:ident transparent: $transparent:ident source: $source:ident
        fmt: $fmt:tt variant: $variant:ident fields: [$($fields:ty),+] rest: $rest:tt
    ) => {
        compile_error!(concat!(
            "geez: variant `", stringify!($variant),
            "` has too many fields (max 8)"
        ));
    };

    // ── emit ───────────────────────────────────────────────────────

    (@emit
        enum_meta: [$(#[$enum_meta:meta])*]
        vis: [$vis:vis]
        name: $name:ident
        variants: [$({
            keep: [$(#[$keep:meta])*]
            from: $from:ident
            transparent: $transparent:ident
            source: $source:ident
            fmt: $fmt:tt
            variant: $variant:ident
            def: [$($def:tt)*]
            disp: [$($disp:tt)*]
            src: [$($src:tt)*]
            args: [$($args:ident),*]
            fields: [$($fields:ty),*]
        })*]
    ) => {
        $(#[$enum_meta])*
        #[derive(Debug)]
        $vis enum $name {
            $(
                $(#[$keep])*
                $($def)*,
            )*
        }

        $vis type Result<T> = ::std::result::Result<T, $name>;

        impl ::std::fmt::Display for $name {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
                match self {
                    $(
                        $($disp)* => {
                            $crate::geez!(@write
                                f
                                $variant
                                transparent: $transparent
                                fmt: $fmt
                                args: [$($args),*]
                            )
                        }
                    )*
                }
            }
        }

        impl ::std::error::Error for $name {
            fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
                match self {
                    $(
                        $($src)* => {
                            $crate::geez!(@source_expr
                                $variant
                                from: $from
                                transparent: $transparent
                                source: $source
                                args: [$($args),*]
                            )
                        }
                    )*
                }
            }
        }

        $(
            $crate::geez!(@from_impl
                $name $variant
                from: $from
                transparent: $transparent
                fields: [$($fields),*]
            );
        )*
    };

    // ── Display body (expression position) ─────────────────────────

    (@write $f:ident $variant:ident transparent: Y fmt: $fmt:tt args: [$inner:ident]) => {
        ::std::write!($f, "{}", $inner)
    };

    (@write $f:ident $variant:ident transparent: Y fmt: $fmt:tt args: []) => {
        {
            compile_error!(concat!(
                "geez: #[transparent] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::write!($f, "")
        }
    };

    (@write $f:ident $variant:ident transparent: Y fmt: $fmt:tt args: [$($args:ident),+]) => {
        {
            compile_error!(concat!(
                "geez: #[transparent] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::write!($f, "")
        }
    };

    (@write $f:ident $variant:ident transparent: N fmt: [$fmt:literal] args: []) => {
        ::std::write!($f, $fmt)
    };

    (@write $f:ident $variant:ident transparent: N fmt: [] args: []) => {
        ::std::write!($f, "{}", stringify!($variant))
    };

    (@write $f:ident $variant:ident transparent: N fmt: [$fmt:literal] args: [$($args:ident),+]) => {
        ::std::write!($f, $fmt, $($args),+)
    };

    (@write $f:ident $variant:ident transparent: N fmt: [] args: [$inner:ident]) => {
        ::std::write!($f, "{}", $inner)
    };

    (@write $f:ident $variant:ident transparent: N fmt: [] args: [$($args:ident),+]) => {
        {
            compile_error!(concat!(
                "geez: multi-field variant `", stringify!($variant),
                "` needs #[error(\"...\")] or => \"...\""
            ));
            ::std::write!($f, "")
        }
    };

    // ── source body ────────────────────────────────────────────────

    (@source_expr
        $variant:ident from: Y transparent: $t:ident source: $s:ident args: [$inner:ident]
    ) => {
        ::std::option::Option::Some($inner as &(dyn ::std::error::Error + 'static))
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: Y source: $s:ident args: [$inner:ident]
    ) => {
        ::std::option::Option::Some($inner as &(dyn ::std::error::Error + 'static))
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: $t:ident source: Y args: [$inner:ident]
    ) => {
        ::std::option::Option::Some($inner as &(dyn ::std::error::Error + 'static))
    };

    (@source_expr
        $variant:ident from: Y transparent: $t:ident source: $s:ident args: []
    ) => {
        {
            compile_error!(concat!(
                "geez: #[from] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: Y transparent: $t:ident source: $s:ident args: [$($a:ident),+]
    ) => {
        {
            compile_error!(concat!(
                "geez: #[from] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: Y source: $s:ident args: []
    ) => {
        {
            compile_error!(concat!(
                "geez: #[transparent] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: Y source: $s:ident args: [$($a:ident),+]
    ) => {
        {
            compile_error!(concat!(
                "geez: #[transparent] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: $t:ident source: Y args: []
    ) => {
        {
            compile_error!(concat!(
                "geez: #[source] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: $f:ident transparent: $t:ident source: Y args: [$($a:ident),+]
    ) => {
        {
            compile_error!(concat!(
                "geez: #[source] on `", stringify!($variant),
                "` needs exactly one field"
            ));
            ::std::option::Option::None
        }
    };

    (@source_expr
        $variant:ident from: N transparent: N source: N args: [$($args:ident),*]
    ) => {
        ::std::option::Option::None
    };

    // ── From ───────────────────────────────────────────────────────

    (@from_impl
        $name:ident $variant:ident
        from: Y transparent: $t:ident fields: [$field:ty]
    ) => {
        impl ::std::convert::From<$field> for $name {
            fn from(value: $field) -> Self {
                $name::$variant(value)
            }
        }
    };

    (@from_impl
        $name:ident $variant:ident
        from: $f:ident transparent: Y fields: [$field:ty]
    ) => {
        impl ::std::convert::From<$field> for $name {
            fn from(value: $field) -> Self {
                $name::$variant(value)
            }
        }
    };

    (@from_impl
        $name:ident $variant:ident
        from: $f:ident transparent: $t:ident fields: $fields:tt
    ) => {};
}