Fail to infer generic arguments of a handler in axum::routing::Router::route()

[GavenKam]

Summary

Hello, I am new to Rust and Axum.
I am setting up my Hello World project. Here is my example that fails to compile:

async fn user_login<T>(
    State(user_service): State<T>,
    Json(body): Json<UserLoginRequest>,
) -> Result<UserLoginView, UserBusinessError>
where
    T: UserService,
{
    let view = user_service.login(&body.code).await?;
    Ok(view)
}

pub fn user_routes(state: AppState) -> Router {
    let AppState { db, jwt, wechat } = state;
    let repo = UserRepository::from(db);
    let service = UserServiceImpl::builder()
        .user_repository(repo)
        .wechat_appid(wechat.appid)
        .wechat_secret(wechat.secret)
        .jwt_user_secret_key(jwt.user_secret_key)
        .jwt_user_ttl(jwt.user_ttl)
        .build();
    Router::new()
        .route(
            "/user/login",
            post(user_login),
        )
        .with_state(service)
}

Rust analyzer correctly infers the types of repo, service and returning Router:

But rustc complains about the handler's generic arguments:

type annotations needed
cannot satisfy _: user_service::traits::UserService
...
consider specifying the generic argument: ::<T>

It is successfully compiled after specifying: user_login::<UserServiceImpl<UserRepository>>, but I think it is troublesome because every time I modify the injected dependencies I need to modify the generic arguments. Is there any solution or shall I switch to another design pattern?
Thank you very much!

axum version

0.8.8

[jplatte]

The problem is that the FromRequest implementation for State<T> is actually generic over two state types - the state type given to the router and the one inside State<T>. The extracted state type must implement FromRef<X> where X is the state type passed to the router - it isn't necessarily the same type. Because of this, type inference can't infer which type to extract from the argument given to with_state.