GAT with HRTB yields weird inference errors.

[aliemjay]

I tried this code: (playground)

#![feature(generic_associated_types)]
use std::marker::PhantomData;

trait AsyncFn<Arg> { type Output; }
trait RequestFamily { type Type<'a>; }
trait Service {}

struct MyFn;
impl AsyncFn<String> for MyFn { type Output = (); }

impl RequestFamily for String { type Type<'a> = String; }

struct ServiceFromAsyncFn<F, Req>(F, PhantomData<Req>);

impl<F, Req, O> Service for ServiceFromAsyncFn<F, Req>
where
    Req: RequestFamily,
    F: AsyncFn<Req>,
    F: for<'a> AsyncFn<Req::Type<'a>, Output = O>,
{
}

fn assert_service() -> impl Service {
    ServiceFromAsyncFn(MyFn, PhantomData)
}

It fails type inference with the following error:

error[E0282]: type annotations needed
  --> src/lib.rs:23:24
   |
23 | fn assert_service() -> impl Service {
   |                        ^^^^^^^^^^^^ cannot infer type for type parameter `O`

This is super weird because type paramters that don't appear in Self type of the impl are not expected to fail inference.
Surprisingly, removing O makes it pass:

-impl<F, Req, O> Service for ServiceFromAsyncFn<F, Req>
+impl<F, Req> Service for ServiceFromAsyncFn<F, Req>
 where
     Req: RequestFamily,
     F: AsyncFn<Req>,
-    F: for<'a> AsyncFn<Req::Type<'a>, Output = O>,
+    F: for<'a> AsyncFn<Req::Type<'a>>,

Meta

Nightly version: 1.62.0-nightly

(2022-05-03 e1b71fe)

@rustbot label F-generic_associated_types T-compiler A-traits A-inference A-lifetimes

[compiler-errors]

It also compiles if we do:

fn assert_service() -> impl Service {
-   ServiceFromAsyncFn(MyFn, PhantomData)
+   ServiceFromAsyncFn(MyFn, PhantomData::<String>)
}

edit: specifying the generic in the ServiceFromAsyncFn also does the same thing

[compiler-errors]

Also like most GAT issues, this seems to be an general underlying higher-kinded + associated types issue:

#![feature(generic_associated_types)]
use std::marker::PhantomData;

trait AsyncFn<Arg> { type Output; }
trait RequestFamily<'a> { type Type; }
trait Service {}

struct MyFn;
impl AsyncFn<String> for MyFn { type Output = (); }

impl RequestFamily<'_> for String { type Type = String; }

struct ServiceFromAsyncFn<F, Req>(F, PhantomData<Req>);

impl<F, Req, O> Service for ServiceFromAsyncFn<F, Req>
where
    Req: for<'a> RequestFamily<'a>,
    F: AsyncFn<Req>,
    F: for<'a> AsyncFn<<Req as RequestFamily<'a>>::Type, Output = O>,
{
}

fn assert_service() -> impl Service {
    ServiceFromAsyncFn(MyFn, PhantomData)
}

Also fails 😅

[aliemjay]

Prior to #90887, this code is rejected as some form of HRTB projections bugs.

At present it is accepted with the following limitations:

• This inference bug!
• Swapping the last two bounds makes it fail unconditionally. Reported in Ordering of bounds matters with GAT/HRTB #96321.

It's not even obvious if the PR #90887 was intended to fix this use case!

[compiler-errors]

I'm actually surprised that this continues to be ambiguous even after #90887. I have been somewhat out of commission this past week, but I may find some time soon to investigate why this inference issue still persists.

[aliemjay]

FWIW using Fn instead of AsyncFn works unconditionally even when swapping the order of the last two bounds:

#![feature(generic_associated_types)]
use std::marker::PhantomData;

trait RequestFamily { type Type<'a>; }
trait Service {}

impl RequestFamily for String { type Type<'a> = String; }

struct ServiceFromAsyncFn<F, Req>(F, PhantomData<Req>);

impl<F, Req, O, O2> Service for ServiceFromAsyncFn<F, Req>
where
    Req: RequestFamily,
    F: Fn(Req) -> O2,
    F: for<'a> Fn(Req::Type<'a>) -> O,
{
}

fn assert_service() -> impl Service {
    fn my_fn(_: String) {}
    ServiceFromAsyncFn(my_fn, PhantomData)
}