Add support for impl Traits and macro_rules!

[JadKHaddad]

Consider the following state with some generic types:

#[derive(Debug, Clone)]
struct MyState<D, A, O> {
    database: D,
    auth: A,
    other: O,
}

trait DatabaseService {}

#[derive(Debug, Clone)]
struct DatabaseImpl {}

impl DatabaseService for DatabaseImpl {}

trait AuthService {}

#[derive(Debug, Clone)]
struct AuthImpl {}

impl AuthService for AuthImpl {}

trait OtherService {}

#[derive(Debug, Clone)]
struct OtherImpl;

impl OtherService for OtherImpl {}

Axum allows extracting the state with impl Traits:

async fn index(
    State(my_state): State<MyState<impl DatabaseService, impl AuthService, impl OtherService>>,
) -> String {
    String::from("Hi")
}

However, if we want to add a new generic type to the state or remove an old one, we have to adjust every route that uses the state, which can be very challenging. So let's define a macro that expands to our state and use it instead:

macro_rules! State {
    () => {
        MyState<impl DatabaseService, impl AuthService, impl OtherService>
    };
}

async fn index(State(my_state): State<State!()>) -> String {
    String::from("Hi")
}

Unfortunately, utoipa does not support either of the approaches above:

unexpected type in component part get type path, expected one of: Path, Tuple, Reference, Group, Array, Slice, TraitObject

[juhaku]

Sure this would be enhancement for sure, but it needs some experimenting around. It might just be quick and simple thing to add but cannot state for sure.

[JadKHaddad]

The Impl Trait can be as easy as updating TypeTree::get_type_tree_values like:

//...
Type::ImplTrait(impl_trait) => impl_trait
        .bounds
        .iter()
        .find_map(|bound| match &bound {
            syn::TypeParamBound::Trait(trait_bound) => Some(&trait_bound.path),
            syn::TypeParamBound::Lifetime(_) => None,
            syn::TypeParamBound::Verbatim(_) => None,
            _ => todo!("TypeTree impl trait found unrecognized TypeParamBound"),
        })
        .map(|path| TypeTreeValueIter::once(TypeTreeValue::Path(path)))
        .unwrap_or_else(TypeTreeValueIter::empty)
//...

For the macro_rules!, I added

//...
Type::Macro(_) => TypeTreeValueIter::once(TypeTreeValue::UnitType)
//...

But I'm not sure, if this is the right way to do it

[juhaku]

Yup, something like that should be done, the macro_rules needs some experimenting on how and if possible to parse the macro rules body if necessary in first place.