replace_self_ty/

lib.rs

//! Macro magic to replace all instances of `Self` in a token tree.
//!
//! Mostly for illustration / learning purposes, check out [the source] for
//! details on how it works.
//!
//! See also:
//! - [The Little Book of Rust Macros](https://lukaswirth.dev/tlborm/).
//! - [Anything you can do, I can do worse with macro_rules!](https://www.youtube.com/watch?v=7uSM60jlkBE).
//! - [Aurorans Solis' Blog](https://auroranssolis.github.io/).
//!
//! [the source]: https://github.com/madsmtm/replace_self_ty
#![no_std]

/// Replace instances of `Self` with another type inside a syntax tree.
///
/// This isn't that useful by itself, but it might be useful inside larger
/// macros that wants to use the result in a context outside of an `impl`.
///
/// # Examples
///
/// ```
/// use replace_self_ty::replace_self_ty;
///
/// struct Foo;
///
/// replace_self_ty! {
///     (Foo)
///
///     impl Foo {
///         fn foo(self: &Self) -> Self {
///             Self
///         }
///     }
/// }
///
/// // Becomes:
/// // impl Foo {
/// //     fn foo(self: &Foo) -> Foo {
/// //         Foo
/// //     }
/// // }
/// ```
///
/// # Limitations
///
/// This works at the syntax level, so it cannot handle cases like:
///
/// ```
/// use replace_self_ty::replace_self_ty;
///
/// struct Foo;
///
/// macro_rules! get_self {
///     () => {
///         Self
///     };
/// }
///
/// replace_self_ty! {
///     (Foo)
///
///     impl Foo {
///         fn foo() -> get_self!() {
///             get_self!()
///         }
///     }
/// }
///
/// // `get_self!()` isn't replaced by `Foo`.
/// ```
///
/// For large syntax trees, it also requires a fairly large recursion limit,
/// so this is probably unsuitable for that (at least with the current
/// implementation).
#[macro_export]
macro_rules! replace_self_ty {
    (
        // The type that we want to replace `Self` with.
        ($($new_self_ty:tt)*)

        // The syntax tree that we want to replace `Self` in.
        $($t:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($t)*)
            ()

            ($crate::__replace_self_ty_out)
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __replace_self_ty_inner {
    // Nothing more to parse; we're done.
    (
        ($($new_self_ty:tt)*)
        ()
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        // compile_error!(stringify!($($parsed)*));
        $($out_macro)* ! {
            $($out_args)*

            ($($parsed)*)
        }
    };

    // Found Self type; replace it and continue.
    (
        ($($new_self_ty:tt)*)
        (Self $($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)* $($new_self_ty)*)

            ($($out_macro)*)
            $($out_args)*
        }
    };

    // Recurse into different kinds of token groups.

    // Parentheses.
    (
        ($($new_self_ty:tt)*)
        (($($inner:tt)*) $($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($inner)*)
            ()

            ($crate::__replace_self_ty_in_parentheses)
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)*)

            ($($out_macro)*)
            ($($out_args)*)
        }
    };

    // Square brackets.
    (
        ($($new_self_ty:tt)*)
        ([$($inner:tt)*] $($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($inner)*)
            ()

            ($crate::__replace_self_ty_in_square_brackets)
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)*)

            ($($out_macro)*)
            ($($out_args)*)
        }
    };

    // Curly brackets.
    (
        ($($new_self_ty:tt)*)
        ({$($inner:tt)*} $($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($inner)*)
            ()

            ($crate::__replace_self_ty_in_curly_brackets)
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)*)

            ($($out_macro)*)
            ($($out_args)*)
        }
    };

    // Any other token tree is simply passed onwards.
    (
        ($($new_self_ty:tt)*)
        ($token:tt $($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        $($out_args:tt)*
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)* $token)

            ($($out_macro)*)
            $($out_args)*
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __replace_self_ty_in_parentheses {
    (
        ($($new_self_ty:tt)*)
        ($($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        ($($out_args:tt)*)

        ($($parsed_group:tt)*)
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)* ($($parsed_group)*))

            ($($out_macro)*)
            $($out_args)*
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __replace_self_ty_in_square_brackets {
    (
        ($($new_self_ty:tt)*)
        ($($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        ($($out_args:tt)*)

        ($($parsed_group:tt)*)
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)* [$($parsed_group)*])

            ($($out_macro)*)
            $($out_args)*
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __replace_self_ty_in_curly_brackets {
    (
        ($($new_self_ty:tt)*)
        ($($rest:tt)*)
        ($($parsed:tt)*)

        ($($out_macro:tt)*)
        ($($out_args:tt)*)

        ($($parsed_group:tt)*)
    ) => {
        $crate::__replace_self_ty_inner! {
            ($($new_self_ty)*)
            ($($rest)*)
            ($($parsed)* {$($parsed_group)*})

            ($($out_macro)*)
            $($out_args)*
        }
    };
}

#[doc(hidden)]
#[macro_export]
macro_rules! __replace_self_ty_out {
    (
        ($($parsed:tt)*)
    ) => {
        $($parsed)*
    };
}