Add unpolished, experimental support for AFIDT (async fn in dyn trait) #133122

compiler-errors · 2024-11-16T20:26:58Z

This allows us to begin messing around async fn in dyn Trait. Calling an async fn from a trait object always returns a dyn* Future<Output = ...>.

To make it work, Implementations are currently required to return something that can be coerced to a dyn* Future (see the example in tests/ui/async-await/dyn/works.rs). If it's not the right size, then it'll raise an error at the coercion site (see the example in tests/ui/async-await/dyn/wrong-size.rs). Currently the only practical way of doing this is wrapping the body in Box::pin(async move { .. }).

This PR does not implement a helper type like a "Boxing"¹ adapter, and I'll probably follow-up with another PR to improve the error message for the PointerLike trait (something that explains in just normal prose what is happening here, rather than a trait error).

This PR also does not implement new trait solver support for AFIDT; I'll need to think how best to integrate it into candidate assembly, and that's a bit of a matter of taste, but I don't think it will be difficult to do.

This could also be generalized:

To work on functions that are -> impl Future (soon).
To work on functions that are -> impl Iterator and other "dyn rpitit safe" traits. We still need to nail down exactly what is needed for this to be okay (not soon).

Tracking:

Tracking Issue for async_fn_in_dyn_trait #133119

https://rust-lang.github.io/async-fundamentals-initiative/explainer/user_guide_future.html#the-boxing-adapter ↩

rustbot · 2024-11-16T20:27:06Z

r? @nnethercote

rustbot has assigned @nnethercote.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

rustbot · 2024-11-16T20:27:08Z

Some changes occurred to MIR optimizations

cc @rust-lang/wg-mir-opt

compiler-errors · 2024-11-16T20:28:00Z

r? types

Probably best for a types team review.

bors · 2024-11-19T00:37:45Z

☔ The latest upstream changes (presumably #132460) made this pull request unmergeable. Please resolve the merge conflicts.

tests/ui/async-await/dyn/works.rs

oli-obk · 2024-12-04T19:43:37Z

compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs

    if tcx.asyncness(fn_def_id).is_async() {
-        return Some(MethodViolationCode::AsyncFn);
+        if tcx.features().async_fn_in_dyn_trait() {


instead of rejecting if the feature is not enabled, we could always use code path for when the feature is enabled and just emit a feature gate error. Or are you trying to not impact stable code for now in diagnostics?

I guess we could. I'm gonna leave it as a follow-up, since this needs to be reworked once again to support -> impl Future style RPITITs.

compiler/rustc_middle/src/ty/return_position_impl_trait_in_trait.rs

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

compiler/rustc_ty_utils/src/abi.rs

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

…li-obk `fn_sig_for_fn_abi` should return a `ty::FnSig`, no need for a binder r? oli-obk Split out of rust-lang#133122

Rollup merge of rust-lang#133874 - compiler-errors:fn-sig-binder, r=oli-obk `fn_sig_for_fn_abi` should return a `ty::FnSig`, no need for a binder r? oli-obk Split out of rust-lang#133122

jackh726 · 2024-12-05T15:50:30Z

Sorry I never finished my review here >.<

Looking through my drafted comments, seems like Oli got them all.

Add unpolished, experimental support for AFIDT (async fn in dyn trait) This allows us to begin messing around `async fn` in `dyn Trait`. Calling an async fn from a trait object always returns a `dyn* Future<Output = ...>`. To make it work, Implementations are currently required to return something that can be coerced to a `dyn* Future` (see the example in `tests/ui/async-await/dyn/works.rs`). If it's not the right size, then it'll raise an error at the coercion site (see the example in `tests/ui/async-await/dyn/wrong-size.rs`). Currently the only practical way of doing this is wrapping the body in `Box::pin(async move { .. })`. This PR does not implement a helper type like a "`Boxing`"[^boxing] adapter, and I'll probably follow-up with another PR to improve the error message for the `PointerLike` trait (something that explains in just normal prose what is happening here, rather than a trait error). [^boxing]: https://rust-lang.github.io/async-fundamentals-initiative/explainer/user_guide_future.html#the-boxing-adapter This PR also does not implement new trait solver support for AFIDT; I'll need to think how best to integrate it into candidate assembly, and that's a bit of a matter of taste, but I don't think it will be difficult to do. This could also be generalized: * To work on functions that are `-> impl Future` (soon). * To work on functions that are `-> impl Iterator` and other "dyn rpitit safe" traits. We still need to nail down exactly what is needed for this to be okay (not soon). Tracking: * rust-lang#133119

Rollup of 10 pull requests Successful merges: - rust-lang#131558 (Lint on combining `#[no_mangle]` and `#[export_name]`) - rust-lang#133122 (Add unpolished, experimental support for AFIDT (async fn in dyn trait)) - rust-lang#133184 (wasi/fs: Improve stopping condition for <ReadDir as Iterator>::next) - rust-lang#133456 (Add licenses + Run `cargo update`) - rust-lang#133472 (Run TLS destructors for wasm32-wasip1-threads) - rust-lang#133853 (use vendor sources by default on dist tarballs) - rust-lang#133946 (coverage: Prefer to visit nodes whose predecessors have been visited) - rust-lang#134010 (fix ICE on type error in promoted) - rust-lang#134029 (coverage: Use a query to find counters/expressions that must be zero) - rust-lang#134071 (Configure renovatebot) r? `@ghost` `@rustbot` modify labels: rollup

fmease · 2024-12-10T07:54:33Z

#134099 (comment)
@bors r-

compiler/rustc_middle/src/ty/return_position_impl_trait_in_trait.rs

compiler-errors · 2024-12-10T19:04:23Z

Added the check for Self: Sized :)

@bors r=oli-obk

bors · 2024-12-10T19:04:25Z

📌 Commit 57e8a1c has been approved by oli-obk

It is now in the queue for this repository.

Add unpolished, experimental support for AFIDT (async fn in dyn trait) This allows us to begin messing around `async fn` in `dyn Trait`. Calling an async fn from a trait object always returns a `dyn* Future<Output = ...>`. To make it work, Implementations are currently required to return something that can be coerced to a `dyn* Future` (see the example in `tests/ui/async-await/dyn/works.rs`). If it's not the right size, then it'll raise an error at the coercion site (see the example in `tests/ui/async-await/dyn/wrong-size.rs`). Currently the only practical way of doing this is wrapping the body in `Box::pin(async move { .. })`. This PR does not implement a helper type like a "`Boxing`"[^boxing] adapter, and I'll probably follow-up with another PR to improve the error message for the `PointerLike` trait (something that explains in just normal prose what is happening here, rather than a trait error). [^boxing]: https://rust-lang.github.io/async-fundamentals-initiative/explainer/user_guide_future.html#the-boxing-adapter This PR also does not implement new trait solver support for AFIDT; I'll need to think how best to integrate it into candidate assembly, and that's a bit of a matter of taste, but I don't think it will be difficult to do. This could also be generalized: * To work on functions that are `-> impl Future` (soon). * To work on functions that are `-> impl Iterator` and other "dyn rpitit safe" traits. We still need to nail down exactly what is needed for this to be okay (not soon). Tracking: * rust-lang#133119

…llaumeGomez Rollup of 8 pull requests Successful merges: - rust-lang#122003 (link libunwind dynamically and allow controlling it via `crt-static` on gnullvm targets) - rust-lang#133122 (Add unpolished, experimental support for AFIDT (async fn in dyn trait)) - rust-lang#133859 (Move some alloc tests to the alloctests crate) - rust-lang#134095 ([CI] Use a lockfile for installing the `datadog` package) - rust-lang#134155 (Forbid `unsafe_op_in_unsafe_fn` for Hurd) - rust-lang#134173 (allow `symbol_intern_string_literal` lint in test modules) - rust-lang#134178 (Stabilize the Rust 2024 prelude) - rust-lang#134179 (Remove outdated consteval note from `<*mut T>::align_offset` docs.) r? `@ghost` `@rustbot` modify labels: rollup

Add unpolished, experimental support for AFIDT (async fn in dyn trait) This allows us to begin messing around `async fn` in `dyn Trait`. Calling an async fn from a trait object always returns a `dyn* Future<Output = ...>`. To make it work, Implementations are currently required to return something that can be coerced to a `dyn* Future` (see the example in `tests/ui/async-await/dyn/works.rs`). If it's not the right size, then it'll raise an error at the coercion site (see the example in `tests/ui/async-await/dyn/wrong-size.rs`). Currently the only practical way of doing this is wrapping the body in `Box::pin(async move { .. })`. This PR does not implement a helper type like a "`Boxing`"[^boxing] adapter, and I'll probably follow-up with another PR to improve the error message for the `PointerLike` trait (something that explains in just normal prose what is happening here, rather than a trait error). [^boxing]: https://rust-lang.github.io/async-fundamentals-initiative/explainer/user_guide_future.html#the-boxing-adapter This PR also does not implement new trait solver support for AFIDT; I'll need to think how best to integrate it into candidate assembly, and that's a bit of a matter of taste, but I don't think it will be difficult to do. This could also be generalized: * To work on functions that are `-> impl Future` (soon). * To work on functions that are `-> impl Iterator` and other "dyn rpitit safe" traits. We still need to nail down exactly what is needed for this to be okay (not soon). Tracking: * rust-lang#133119

Rollup of 13 pull requests Successful merges: - rust-lang#122003 (link libunwind dynamically and allow controlling it via `crt-static` on gnullvm targets) - rust-lang#133122 (Add unpolished, experimental support for AFIDT (async fn in dyn trait)) - rust-lang#133859 (Move some alloc tests to the alloctests crate) - rust-lang#134070 (Some asm! diagnostic adjustments and a papercut fix) - rust-lang#134095 ([CI] Use a lockfile for installing the `datadog` package) - rust-lang#134144 (Properly consider APITs for never type fallback ascription fix) - rust-lang#134152 (Simplify `rustc_mir_dataflow::abs_domain`.) - rust-lang#134154 (suppress field expr with generics error message if it's a method) - rust-lang#134155 (Forbid `unsafe_op_in_unsafe_fn` for Hurd) - rust-lang#134173 (allow `symbol_intern_string_literal` lint in test modules) - rust-lang#134178 (Stabilize the Rust 2024 prelude) - rust-lang#134179 (Remove outdated consteval note from `<*mut T>::align_offset` docs.) - rust-lang#134187 (Remove `PErr`.) r? `@ghost` `@rustbot` modify labels: rollup

…iaskrgr Rollup of 7 pull requests Successful merges: - rust-lang#133122 (Add unpolished, experimental support for AFIDT (async fn in dyn trait)) - rust-lang#133249 (ABI checks: add support for loongarch) - rust-lang#134089 (Use newly added exceptions to non default branch warning) - rust-lang#134188 (Bump Fuchsia) - rust-lang#134204 (Fix our `llvm::Bool` typedef to be signed, to match `LLVMBool`) - rust-lang#134207 (Revert "bootstrap: print{ln}! -> eprint{ln}! (take 2) rust-lang#134040") - rust-lang#134214 (rustdoc: fix self cmp) r? `@ghost` `@rustbot` modify labels: rollup

Rollup merge of rust-lang#133122 - compiler-errors:afidt, r=oli-obk Add unpolished, experimental support for AFIDT (async fn in dyn trait) This allows us to begin messing around `async fn` in `dyn Trait`. Calling an async fn from a trait object always returns a `dyn* Future<Output = ...>`. To make it work, Implementations are currently required to return something that can be coerced to a `dyn* Future` (see the example in `tests/ui/async-await/dyn/works.rs`). If it's not the right size, then it'll raise an error at the coercion site (see the example in `tests/ui/async-await/dyn/wrong-size.rs`). Currently the only practical way of doing this is wrapping the body in `Box::pin(async move { .. })`. This PR does not implement a helper type like a "`Boxing`"[^boxing] adapter, and I'll probably follow-up with another PR to improve the error message for the `PointerLike` trait (something that explains in just normal prose what is happening here, rather than a trait error). [^boxing]: https://rust-lang.github.io/async-fundamentals-initiative/explainer/user_guide_future.html#the-boxing-adapter This PR also does not implement new trait solver support for AFIDT; I'll need to think how best to integrate it into candidate assembly, and that's a bit of a matter of taste, but I don't think it will be difficult to do. This could also be generalized: * To work on functions that are `-> impl Future` (soon). * To work on functions that are `-> impl Iterator` and other "dyn rpitit safe" traits. We still need to nail down exactly what is needed for this to be okay (not soon). Tracking: * rust-lang#133119

rustbot assigned nnethercote Nov 16, 2024

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. T-compiler Relevant to the compiler team, which will review and decide on the PR/issue. labels Nov 16, 2024

rustbot added the T-types Relevant to the types team, which will review and decide on the PR/issue. label Nov 16, 2024

rustbot assigned jackh726 and unassigned nnethercote Nov 16, 2024

compiler-errors mentioned this pull request Nov 16, 2024

Tracking Issue for async_fn_in_dyn_trait #133119

Open

7 tasks

This comment has been minimized.

Sign in to view

compiler-errors force-pushed the afidt branch from 9600e7d to 591f99f Compare November 18, 2024 23:24

compiler-errors force-pushed the afidt branch from 591f99f to e7fdb2e Compare November 19, 2024 16:30

oli-obk assigned oli-obk and unassigned jackh726 Dec 4, 2024

cramertj reviewed Dec 4, 2024

View reviewed changes

tests/ui/async-await/dyn/works.rs Show resolved Hide resolved

compiler-errors force-pushed the afidt branch from e7fdb2e to e12e02d Compare December 4, 2024 17:42

This comment has been minimized.

Sign in to view

compiler-errors force-pushed the afidt branch from e12e02d to 4ffdaa3 Compare December 4, 2024 18:09

oli-obk reviewed Dec 4, 2024

View reviewed changes

compiler-errors mentioned this pull request Dec 4, 2024

fn_sig_for_fn_abi should return a ty::FnSig, no need for a binder #133874

Merged

compiler-errors force-pushed the afidt branch from 4ffdaa3 to 8989451 Compare December 4, 2024 21:15

This comment has been minimized.

Sign in to view

compiler-errors force-pushed the afidt branch from 8989451 to 22033d1 Compare December 4, 2024 21:31

fmease added a commit to fmease/rust that referenced this pull request Dec 4, 2024

Rollup merge of rust-lang#133874 - compiler-errors:fn-sig-binder, r=o…

a01ea86

…li-obk `fn_sig_for_fn_abi` should return a `ty::FnSig`, no need for a binder r? oli-obk Split out of rust-lang#133122

fmease added a commit to fmease/rust that referenced this pull request Dec 4, 2024

Rollup merge of rust-lang#133874 - compiler-errors:fn-sig-binder, r=o…

ccb6845

…li-obk `fn_sig_for_fn_abi` should return a `ty::FnSig`, no need for a binder r? oli-obk Split out of rust-lang#133122

fmease added a commit to fmease/rust that referenced this pull request Dec 5, 2024

Rollup merge of rust-lang#133874 - compiler-errors:fn-sig-binder, r=o…

4f99d6c

…li-obk `fn_sig_for_fn_abi` should return a `ty::FnSig`, no need for a binder r? oli-obk Split out of rust-lang#133122

bors added the S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. label Dec 9, 2024

fmease mentioned this pull request Dec 9, 2024

Rollup of 11 pull requests #134098

Closed

fmease mentioned this pull request Dec 9, 2024

Rollup of 10 pull requests #134099

Closed

bors added S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. and removed S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. labels Dec 10, 2024

oli-obk reviewed Dec 10, 2024

View reviewed changes

compiler/rustc_middle/src/ty/return_position_impl_trait_in_trait.rs Show resolved Hide resolved

compiler-errors added 2 commits December 10, 2024 16:52

Add feature gate, not working yet

3b05779

Implement projection and shim for AFIDT

a7fa4cb

compiler-errors force-pushed the afidt branch from 3511a46 to b482339 Compare December 10, 2024 17:21

Don't check RPITITs that are Self:Sized for PointerLike

57e8a1c

compiler-errors force-pushed the afidt branch from b482339 to 57e8a1c Compare December 10, 2024 17:23

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-author Status: This is awaiting some action (such as code changes or more information) from the author. labels Dec 10, 2024

GuillaumeGomez mentioned this pull request Dec 11, 2024

Rollup of 8 pull requests #134184

Closed

jieyouxu mentioned this pull request Dec 12, 2024

Rollup of 13 pull requests #134195

Closed

matthiaskrgr mentioned this pull request Dec 12, 2024

Rollup of 7 pull requests #134223

Merged

bors merged commit 2e8807d into rust-lang:master Dec 12, 2024
6 checks passed

rustbot added this to the 1.85.0 milestone Dec 12, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add unpolished, experimental support for AFIDT (async fn in dyn trait) #133122

Add unpolished, experimental support for AFIDT (async fn in dyn trait) #133122

compiler-errors commented Nov 16, 2024 •

edited

Loading

rustbot commented Nov 16, 2024

rustbot commented Nov 16, 2024

compiler-errors commented Nov 16, 2024

This comment has been minimized.

bors commented Nov 19, 2024

This comment has been minimized.

oli-obk Dec 4, 2024

compiler-errors Dec 4, 2024

This comment has been minimized.

jackh726 commented Dec 5, 2024

fmease commented Dec 10, 2024

compiler-errors commented Dec 10, 2024

bors commented Dec 10, 2024

Add unpolished, experimental support for AFIDT (async fn in dyn trait) #133122

Add unpolished, experimental support for AFIDT (async fn in dyn trait) #133122

Conversation

compiler-errors commented Nov 16, 2024 • edited Loading

Footnotes

rustbot commented Nov 16, 2024

rustbot commented Nov 16, 2024

compiler-errors commented Nov 16, 2024

This comment has been minimized.

bors commented Nov 19, 2024

This comment has been minimized.

oli-obk Dec 4, 2024

Choose a reason for hiding this comment

compiler-errors Dec 4, 2024

Choose a reason for hiding this comment

This comment has been minimized.

jackh726 commented Dec 5, 2024

fmease commented Dec 10, 2024

compiler-errors commented Dec 10, 2024

bors commented Dec 10, 2024

compiler-errors commented Nov 16, 2024 •

edited

Loading