type inference fails when using `async_fn_in_trait`

[LastExceed]

#![feature(async_fn_in_trait)]

fn main() {}

trait MyTrait<T> {
	async fn foo(&mut self) -> T;
}


impl<T> MyTrait<bool> for T {
	async fn foo(&mut self) -> bool {
		true
	}
}

impl<T> MyTrait<i32> for T {
	async fn foo(&mut self) -> i32 {
		let x: bool = self.foo().await; //error[E0698]: type inside `async fn` body must be known in this context

		42
	}
}

works fine when removing async or using the async-trait crate

workaround:

let x: bool = MyTrait::<bool>::foo(self).await;

[compiler-errors]

This issue isn't really related to async fn in trait itself, but more a limitation of opaque type inference (since opaques power async fn in trait):

#![feature(impl_trait_in_assoc_type)]
use core::future::Future;

fn main() {}

trait MyTrait<T> {
    type Foo<'a>: Future<Output = T> + 'a
    where
        Self: 'a;

    fn foo(&mut self) -> Self::Foo<'_>;
}

impl<T> MyTrait<bool> for T {
    type Foo<'a> = impl Future<Output = bool> + 'a
	where
		T: 'a;

    fn foo(&mut self) -> Self::Foo<'_> {
        async { true }
    }
}

impl<T> MyTrait<i32> for T {
    type Foo<'a> = impl Future<Output = i32> + 'a
	where
		T: 'a;

    fn foo(&mut self) -> Self::Foo<'_> {
        async {
            let x: bool = self.foo().await; //error[E0698]: type inside `async fn` body must be known in this context
            42
        }
    }
}

[compiler-errors]

Actually, this is also just a limitation of the double indirection of async:

use futures::future::LocalBoxFuture;
use core::future::Future;

fn main() {}

trait MyTrait<T> {
    type Foo<'a>: Future<Output = T> + 'a
    where
        Self: 'a;

    fn foo(&mut self) -> Self::Foo<'_>;
}

impl<T> MyTrait<bool> for T {
    type Foo<'a> = LocalBoxFuture<'a, bool>
	where
		T: 'a;

    fn foo(&mut self) -> Self::Foo<'_> {
        Box::pin(async { true })
    }
}

impl<T> MyTrait<i32> for T {
    type Foo<'a> = LocalBoxFuture<'a, i32>
	where
		T: 'a;

    fn foo(&mut self) -> Self::Foo<'_> {
        Box::pin(async {
            let x: bool = self.foo().await; //error[E0698]: type inside `async fn` body must be known in this context
            42
        })
    }
}

[compiler-errors]

Actually, this isn't even a bug with AFIT. This is just an async bug:

fn main() {}

fn foo<T: Default>() -> T {
    T::default()
}

async fn bar() -> i32 {
    let x: bool = foo().await; //error[E0698]: type inside `async fn` body must be known in this context
    42
}

edit: see below