type inference fails when using async_fn_in_trait

#![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;

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
        }
    }
}

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
        })
    }
}

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

Details

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

Auto merge of rust-lang#115822 - compiler-errors:stabilize-rpitit, r=…

Auto merge of #115822 - compiler-errors:stabilize-rpitit, r=jackh726

@compiler-errors

We discussed this in the WG-async triage meeting. The feeling was that this may be difficult to fix and that it may be due to indirection introduced in the .await desugaring. To investigate further, someone might manually desugar .await to see where the ambiguity is originating.

(Thanks in particular to @compiler-errors.)

I'm an idiot. The code I provided was just not well-formed. Let me look into this again I guess.

current output:

error[E0284]: type annotations needed
  --> src/main.rs:18:22
   |
18 |         let x: bool = self.foo().await; //error[E0698]: type inside `async fn` body must be known in this context
   |                            ^^^
   |
   = note: cannot satisfy `impl Future<Output = _> == _`
help: try using a fully qualified path to specify the expected types
   |
18 |         let x: bool = <T as MyTrait<T>>::foo(self).await; //error[E0698]: type inside `async fn` body must be known in this context
   |                       +++++++++++++++++++++++    ~

error[E0283]: type annotations needed
  --> src/main.rs:18:22
   |
18 |         let x: bool = self.foo().await; //error[E0698]: type inside `async fn` body must be known in this context
   |                            ^^^
   |
note: multiple `impl`s satisfying `T: MyTrait<_>` found
  --> src/main.rs:10:1
   |
10 | impl<T> MyTrait<bool> for T {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
16 | impl<T> MyTrait<i32> for T {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
help: try using a fully qualified path to specify the expected types
   |
18 |         let x: bool = <T as MyTrait<T>>::foo(self).await; //error[E0698]: type inside `async fn` body must be known in this context
   |                       +++++++++++++++++++++++    ~

Some errors have detailed explanations: E0283, E0284.
For more information about an error, try `rustc --explain E0283`.

Navigation Menu

Repository navigation

type inference fails when using `async_fn_in_trait` #108362

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

type inference fails when using async_fn_in_trait #108362

Description

Activity

compiler-errors commented on Jun 12, 2023

compiler-errors commented on Sep 11, 2023

compiler-errors commented on Sep 13, 2023

traviscross commented on Dec 18, 2023

compiler-errors commented on Dec 18, 2023

Dylan-DPC commented on Jan 9, 2025

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions

type inference fails when using `async_fn_in_trait` #108362