mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Stabilize async closures

Browse source
This commit is contained in:
Michael Goulet 2024-11-06 17:53:59 +00:00
parent d4025ee454
commit c605c84be8
184 changed files with 311 additions and 553 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
compiler/rustc_ast_passes/src/feature_gate.rs
View file

@ -511,11 +511,6 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
"you can write `if matches!(<expr>, <pattern>)` instead of `if let <pattern> = <expr>`"
);
gate_all!(let_chains, "`let` expressions in this position are unstable");
gate_all!(
async_closure,
"async closures are unstable",
"to use an async block, remove the `||`: `async {`"
);
gate_all!(
async_trait_bounds,
"`async` trait bounds are unstable",

4
compiler/rustc_error_codes/src/error_codes/E0708.md
View file

@ -5,8 +5,6 @@
Erroneous code example:
```edition2018
#![feature(async_closure)]
fn main() {
let add_one = async |num: u8| {
num + 1
@ -18,8 +16,6 @@ fn main() {
version, you can use successfully by using move:
```edition2018
#![feature(async_closure)]
fn main() {
let add_one = async move |num: u8| { // ok!
num + 1

2
compiler/rustc_feature/src/accepted.rs
View file

@ -72,6 +72,8 @@ declare_features! (
(accepted, associated_types, "1.0.0", None),
/// Allows free and inherent `async fn`s, `async` blocks, and `<expr>.await` expressions.
(accepted, async_await, "1.39.0", Some(50547)),
/// Allows `async || body` closures.
(accepted, async_closure, "CURRENT_RUSTC_VERSION", Some(62290)),
/// Allows async functions to be declared, implemented, and used in traits.
(accepted, async_fn_in_trait, "1.75.0", Some(91611)),
/// Allows all literals in attribute lists and values of key-value pairs.

2
compiler/rustc_feature/src/unstable.rs
View file

@ -388,8 +388,6 @@ declare_features! (
(unstable, associated_const_equality, "1.58.0", Some(92827)),
/// Allows associated type defaults.
(unstable, associated_type_defaults, "1.2.0", Some(29661)),
/// Allows `async || body` closures.
(unstable, async_closure, "1.37.0", Some(62290)),
/// Allows async functions to be called from `dyn Trait`.
(incomplete, async_fn_in_dyn_trait, "CURRENT_RUSTC_VERSION", Some(133119)),
/// Allows `#[track_caller]` on async functions.

2
compiler/rustc_hir_typeck/src/upvar.rs
View file

@ -1840,7 +1840,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// captured by move.
///
/// ```rust
/// #![feature(async_closure)]
/// let x = &1i32; // Let's call this lifetime `'1`.
/// let c = async move || {
/// println!("{:?}", *x);
@ -1855,7 +1854,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// child capture with the lifetime of the parent coroutine-closure's env.
///
/// ```rust
/// #![feature(async_closure)]
/// let mut x = 1i32;
/// let c = async || {
/// x = 1;

4
compiler/rustc_lint/src/async_closures.rs
View file

@ -12,7 +12,6 @@ declare_lint! {
/// ### Example
///
/// ```rust
/// #![feature(async_closure)]
/// #![warn(closure_returning_async_block)]
/// let c = |x: &str| async {};
/// ```
@ -40,8 +39,6 @@ declare_lint! {
/// But it does work with async closures:
///
/// ```rust
/// #![feature(async_closure)]
///
/// async fn callback(x: &str) {}
///
/// let captured_str = String::new();
@ -52,7 +49,6 @@ declare_lint! {
pub CLOSURE_RETURNING_ASYNC_BLOCK,
Allow,
"closure that returns `async {}` could be rewritten as an async closure",
@feature_gate = async_closure;
}
declare_lint_pass!(

2
compiler/rustc_mir_transform/src/coroutine/by_move_body.rs
View file

@ -3,8 +3,6 @@
//!
//! Consider an async closure like:
//! ```rust
//! #![feature(async_closure)]
//!
//! let x = vec![1, 2, 3];
//!
//! let closure = async move || {

5
compiler/rustc_parse/src/parser/expr.rs
View file

@ -2366,10 +2366,7 @@ impl<'a> Parser<'a> {
};
match coroutine_kind {
Some(CoroutineKind::Async { span, .. }) => {
// Feature-gate `async ||` closures.
self.psess.gated_spans.gate(sym::async_closure, span);
}
Some(CoroutineKind::Async { .. }) => {}
Some(CoroutineKind::Gen { span, .. }) | Some(CoroutineKind::AsyncGen { span, .. }) => {
// Feature-gate `gen ||` and `async gen ||` closures.
// FIXME(gen_blocks): This perhaps should be a different gate.

9
library/alloc/src/boxed.rs
View file

@ -1985,7 +1985,8 @@ impl<Args: Tuple, F: Fn<Args> + ?Sized, A: Allocator> Fn<Args> for Box<F, A> {
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args> for Box<F, A> {
type Output = F::Output;
type CallOnceFuture = F::CallOnceFuture;
@ -1995,7 +1996,8 @@ impl<Args: Tuple, F: AsyncFnOnce<Args> + ?Sized, A: Allocator> AsyncFnOnce<Args>
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> for Box<F, A> {
type CallRefFuture<'a>
= F::CallRefFuture<'a>
@ -2007,7 +2009,8 @@ impl<Args: Tuple, F: AsyncFnMut<Args> + ?Sized, A: Allocator> AsyncFnMut<Args> f
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<Args: Tuple, F: AsyncFn<Args> + ?Sized, A: Allocator> AsyncFn<Args> for Box<F, A> {
extern "rust-call" fn async_call(&self, args: Args) -> Self::CallRefFuture<'_> {
F::async_call(self, args)

2
library/alloc/src/lib.rs
View file

@ -91,6 +91,7 @@
//
// Library features:
// tidy-alphabetical-start
#![cfg_attr(bootstrap, feature(async_closure))]
#![cfg_attr(test, feature(str_as_str))]
#![feature(alloc_layout_extra)]
#![feature(allocator_api)]
@ -99,7 +100,6 @@
#![feature(array_windows)]
#![feature(ascii_char)]
#![feature(assert_matches)]
#![feature(async_closure)]
#![feature(async_fn_traits)]
#![feature(async_iterator)]
#![feature(box_uninit_write)]

24
library/core/src/ops/async_function.rs
View file

@ -4,7 +4,8 @@ use crate::marker::Tuple;
/// An async-aware version of the [`Fn`](crate::ops::Fn) trait.
///
/// All `async fn` and functions returning futures implement this trait.
#[unstable(feature = "async_closure", issue = "62290")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
#[rustc_paren_sugar]
#[fundamental]
#[must_use = "async closures are lazy and do nothing unless called"]
@ -18,7 +19,8 @@ pub trait AsyncFn<Args: Tuple>: AsyncFnMut<Args> {
/// An async-aware version of the [`FnMut`](crate::ops::FnMut) trait.
///
/// All `async fn` and functions returning futures implement this trait.
#[unstable(feature = "async_closure", issue = "62290")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
#[rustc_paren_sugar]
#[fundamental]
#[must_use = "async closures are lazy and do nothing unless called"]
@ -39,7 +41,8 @@ pub trait AsyncFnMut<Args: Tuple>: AsyncFnOnce<Args> {
/// An async-aware version of the [`FnOnce`](crate::ops::FnOnce) trait.
///
/// All `async fn` and functions returning futures implement this trait.
#[unstable(feature = "async_closure", issue = "62290")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
#[rustc_paren_sugar]
#[fundamental]
#[must_use = "async closures are lazy and do nothing unless called"]
@ -64,7 +67,8 @@ mod impls {
use super::{AsyncFn, AsyncFnMut, AsyncFnOnce};
use crate::marker::Tuple;
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<A: Tuple, F: ?Sized> AsyncFn<A> for &F
where
F: AsyncFn<A>,
@ -74,7 +78,8 @@ mod impls {
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<A: Tuple, F: ?Sized> AsyncFnMut<A> for &F
where
F: AsyncFn<A>,
@ -89,7 +94,8 @@ mod impls {
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<'a, A: Tuple, F: ?Sized> AsyncFnOnce<A> for &'a F
where
F: AsyncFn<A>,
@ -102,7 +108,8 @@ mod impls {
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<A: Tuple, F: ?Sized> AsyncFnMut<A> for &mut F
where
F: AsyncFnMut<A>,
@ -117,7 +124,8 @@ mod impls {
}
}
#[unstable(feature = "async_fn_traits", issue = "none")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
impl<'a, A: Tuple, F: ?Sized> AsyncFnOnce<A> for &'a mut F
where
F: AsyncFnMut<A>,

3
library/std/src/prelude/common.rs
View file

@ -12,7 +12,8 @@ pub use crate::marker::{Send, Sized, Sync, Unpin};
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use crate::ops::{Drop, Fn, FnMut, FnOnce};
#[unstable(feature = "async_closure", issue = "62290")]
#[cfg_attr(bootstrap, unstable(feature = "async_closure", issue = "62290"))]
#[cfg_attr(not(bootstrap), stable(feature = "async_closure", since = "CURRENT_RUSTC_VERSION"))]
#[doc(no_inline)]
pub use crate::ops::{AsyncFn, AsyncFnMut, AsyncFnOnce};

1
src/tools/clippy/tests/ui/async_yields_async.fixed
View file

@ -1,4 +1,3 @@
#![feature(async_closure)]
#![warn(clippy::async_yields_async)]
#![allow(clippy::redundant_async_block)]

1
src/tools/clippy/tests/ui/async_yields_async.rs
View file

@ -1,4 +1,3 @@
#![feature(async_closure)]
#![warn(clippy::async_yields_async)]
#![allow(clippy::redundant_async_block)]

12
src/tools/clippy/tests/ui/async_yields_async.stderr
View file

@ -1,5 +1,5 @@
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:38:9
--> tests/ui/async_yields_async.rs:37:9
|
LL | let _h = async {
| _____________________-
@ -20,7 +20,7 @@ LL + }.await
|
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:43:9
--> tests/ui/async_yields_async.rs:42:9
|
LL | let _i = async {
| ____________________-
@ -33,7 +33,7 @@ LL | | };
| |_____- outer async construct
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:49:9
--> tests/ui/async_yields_async.rs:48:9
|
LL | let _j = async || {
| ________________________-
@ -52,7 +52,7 @@ LL + }.await
|
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:54:9
--> tests/ui/async_yields_async.rs:53:9
|
LL | let _k = async || {
| _______________________-
@ -65,7 +65,7 @@ LL | | };
| |_____- outer async construct
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:56:23
--> tests/ui/async_yields_async.rs:55:23
|
LL | let _l = async || CustomFutureType;
| ^^^^^^^^^^^^^^^^
@ -75,7 +75,7 @@ LL | let _l = async || CustomFutureType;
| help: consider awaiting this value: `CustomFutureType.await`
error: an async construct yields a type which is itself awaitable
--> tests/ui/async_yields_async.rs:62:9
--> tests/ui/async_yields_async.rs:61:9
|
LL | let _m = async || {
| _______________________-

1
src/tools/clippy/tests/ui/author/blocks.rs
View file

@ -2,7 +2,6 @@
#![allow(redundant_semicolons, clippy::no_effect)]
#![feature(stmt_expr_attributes)]
#![feature(async_closure)]
#[rustfmt::skip]
fn main() {

1
src/tools/clippy/tests/ui/infinite_loops.rs
View file

@ -3,7 +3,6 @@
#![allow(clippy::never_loop)]
#![warn(clippy::infinite_loop)]
#![feature(async_closure)]
extern crate proc_macros;
use proc_macros::{external, with_span};

42
src/tools/clippy/tests/ui/infinite_loops.stderr
View file

@ -1,5 +1,5 @@
error: infinite loop detected
--> tests/ui/infinite_loops.rs:14:5
--> tests/ui/infinite_loops.rs:13:5
|
LL | / loop {
LL | |
@ -15,7 +15,7 @@ LL | fn no_break() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:21:5
--> tests/ui/infinite_loops.rs:20:5
|
LL | / loop {
LL | |
@ -32,7 +32,7 @@ LL | fn all_inf() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:23:9
--> tests/ui/infinite_loops.rs:22:9
|
LL | / loop {
LL | |
@ -49,7 +49,7 @@ LL | fn all_inf() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:25:13
--> tests/ui/infinite_loops.rs:24:13
|
LL | / loop {
LL | |
@ -63,7 +63,7 @@ LL | fn all_inf() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:39:5
--> tests/ui/infinite_loops.rs:38:5
|
LL | / loop {
LL | |
@ -74,7 +74,7 @@ LL | | }
= help: if this is not intended, try adding a `break` or `return` condition in the loop
error: infinite loop detected
--> tests/ui/infinite_loops.rs:52:5
--> tests/ui/infinite_loops.rs:51:5
|
LL | / loop {
LL | | fn inner_fn() -> ! {
@ -90,7 +90,7 @@ LL | fn no_break_never_ret_noise() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:95:5
--> tests/ui/infinite_loops.rs:94:5
|
LL | / loop {
LL | |
@ -107,7 +107,7 @@ LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:106:5
--> tests/ui/infinite_loops.rs:105:5
|
LL | / loop {
LL | |
@ -124,7 +124,7 @@ LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:120:9
--> tests/ui/infinite_loops.rs:119:9
|
LL | / loop {
LL | |
@ -138,7 +138,7 @@ LL | fn break_outer_but_not_inner() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:143:9
--> tests/ui/infinite_loops.rs:142:9
|
LL | / loop {
LL | |
@ -155,7 +155,7 @@ LL | fn break_wrong_loop(cond: bool) -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:183:5
--> tests/ui/infinite_loops.rs:182:5
|
LL | / loop {
LL | |
@ -172,7 +172,7 @@ LL | fn match_like() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:224:5
--> tests/ui/infinite_loops.rs:223:5
|
LL | / loop {
LL | |
@ -186,7 +186,7 @@ LL | fn match_like() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:229:5
--> tests/ui/infinite_loops.rs:228:5
|
LL | / loop {
LL | |
@ -203,7 +203,7 @@ LL | fn match_like() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:334:9
--> tests/ui/infinite_loops.rs:333:9
|
LL | / loop {
LL | |
@ -217,7 +217,7 @@ LL | fn problematic_trait_method() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:344:9
--> tests/ui/infinite_loops.rs:343:9
|
LL | / loop {
LL | |
@ -231,7 +231,7 @@ LL | fn could_be_problematic() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:353:9
--> tests/ui/infinite_loops.rs:352:9
|
LL | / loop {
LL | |
@ -245,7 +245,7 @@ LL | let _loop_forever = || -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:367:8
--> tests/ui/infinite_loops.rs:366:8
|
LL | Ok(loop {
| ________^
@ -256,7 +256,7 @@ LL | | })
= help: if this is not intended, try adding a `break` or `return` condition in the loop
error: infinite loop detected
--> tests/ui/infinite_loops.rs:409:5
--> tests/ui/infinite_loops.rs:408:5
|
LL | / 'infinite: loop {
LL | |
@ -272,7 +272,7 @@ LL | fn continue_outer() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:416:5
--> tests/ui/infinite_loops.rs:415:5
|
LL | / loop {
LL | |
@ -289,7 +289,7 @@ LL | fn continue_outer() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:418:9
--> tests/ui/infinite_loops.rs:417:9
|
LL | / 'inner: loop {
LL | | loop {
@ -304,7 +304,7 @@ LL | fn continue_outer() -> ! {
| ++++
error: infinite loop detected
--> tests/ui/infinite_loops.rs:426:5
--> tests/ui/infinite_loops.rs:425:5
|
LL | / loop {
LL | |

1
src/tools/clippy/tests/ui/redundant_closure_call_fixable.fixed
View file

@ -1,4 +1,3 @@
#![feature(async_closure)]
#![warn(clippy::redundant_closure_call)]
#![allow(clippy::redundant_async_block)]
#![allow(clippy::type_complexity)]

1
src/tools/clippy/tests/ui/redundant_closure_call_fixable.rs
View file

@ -1,4 +1,3 @@
#![feature(async_closure)]
#![warn(clippy::redundant_closure_call)]
#![allow(clippy::redundant_async_block)]
#![allow(clippy::type_complexity)]

34
src/tools/clippy/tests/ui/redundant_closure_call_fixable.stderr
View file

@ -1,5 +1,5 @@
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:16:13
--> tests/ui/redundant_closure_call_fixable.rs:15:13
|
LL | let a = (|| 42)();
| ^^^^^^^^^ help: try doing something like: `42`
@ -8,7 +8,7 @@ LL | let a = (|| 42)();
= help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:17:13
--> tests/ui/redundant_closure_call_fixable.rs:16:13
|
LL | let b = (async || {
| _____________^
@ -28,7 +28,7 @@ LL ~ };
|
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:22:13
--> tests/ui/redundant_closure_call_fixable.rs:21:13
|
LL | let c = (|| {
| _____________^
@ -48,13 +48,13 @@ LL ~ };
|
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:27:13
--> tests/ui/redundant_closure_call_fixable.rs:26:13
|
LL | let d = (async || something().await)();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:36:13
--> tests/ui/redundant_closure_call_fixable.rs:35:13
|
LL | (|| m!())()
| ^^^^^^^^^^^ help: try doing something like: `m!()`
@ -65,7 +65,7 @@ LL | m2!();
= note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:31:13
--> tests/ui/redundant_closure_call_fixable.rs:30:13
|
LL | (|| 0)()
| ^^^^^^^^ help: try doing something like: `0`
@ -76,67 +76,67 @@ LL | m2!();
= note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:44:16
--> tests/ui/redundant_closure_call_fixable.rs:43:16
|
LL | assert_eq!((|| || 43)()(), 42);
| ^^^^^^^^^^^^^^ help: try doing something like: `43`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:53:10
--> tests/ui/redundant_closure_call_fixable.rs:52:10
|
LL | dbg!((|| 42)());
| ^^^^^^^^^ help: try doing something like: `42`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:56:13
--> tests/ui/redundant_closure_call_fixable.rs:55:13
|
LL | let a = (|| || || 123)();
| ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:60:13
--> tests/ui/redundant_closure_call_fixable.rs:59:13
|
LL | let a = (|| || || || async || 1)()()()()();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { 1 }`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:69:13
--> tests/ui/redundant_closure_call_fixable.rs:68:13
|
LL | let a = (|| echo!(|| echo!(|| 1)))()()();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `1`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:71:13
--> tests/ui/redundant_closure_call_fixable.rs:70:13
|
LL | let a = (|| echo!((|| 123)))()();
| ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:84:11
--> tests/ui/redundant_closure_call_fixable.rs:83:11
|
LL | bar()((|| || 42)()(), 5);
| ^^^^^^^^^^^^^^ help: try doing something like: `42`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:85:9
--> tests/ui/redundant_closure_call_fixable.rs:84:9
|
LL | foo((|| || 42)()(), 5);
| ^^^^^^^^^^^^^^ help: try doing something like: `42`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:89:5
--> tests/ui/redundant_closure_call_fixable.rs:88:5
|
LL | (|| async {})().await;
| ^^^^^^^^^^^^^^^ help: try doing something like: `async {}`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:98:18
--> tests/ui/redundant_closure_call_fixable.rs:97:18
|
LL | spawn_on((|| async move {})());
| ^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async move {}`
error: try not to call a closure in the expression where it is declared
--> tests/ui/redundant_closure_call_fixable.rs:103:28
--> tests/ui/redundant_closure_call_fixable.rs:102:28
|
LL | std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
| ^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `13_i32 + 36_i32`

2
src/tools/clippy/tests/ui/redundant_locals.rs
View file

@ -1,7 +1,7 @@
//@aux-build:proc_macros.rs
#![allow(unused, clippy::no_effect, clippy::needless_pass_by_ref_mut)]
#![warn(clippy::redundant_locals)]
#![feature(async_closure, coroutines, stmt_expr_attributes)]
#![feature(coroutines, stmt_expr_attributes)]
extern crate proc_macros;
use proc_macros::{external, with_span};

2
src/tools/miri/tests/pass/async-closure-captures.rs
View file

@ -1,6 +1,6 @@
// Same as rustc's `tests/ui/async-await/async-closures/captures.rs`, keep in sync
#![feature(async_closure, async_trait_bounds)]
#![feature(async_trait_bounds)]
use std::future::Future;
use std::pin::pin;

2
src/tools/miri/tests/pass/async-closure-drop.rs
View file

@ -1,4 +1,4 @@
#![feature(async_closure, async_trait_bounds)]
#![feature(async_fn_traits, async_trait_bounds)]
use std::future::Future;
use std::pin::pin;

2
src/tools/miri/tests/pass/async-closure.rs
View file

@ -1,4 +1,4 @@
#![feature(async_closure, async_fn_traits)]
#![feature(async_fn_traits)]
#![allow(unused)]
use std::future::Future;

2
src/tools/miri/tests/pass/async-drop.rs
View file

@ -6,7 +6,7 @@
// please consider modifying rustc's async drop test at
// `tests/ui/async-await/async-drop.rs`.
#![feature(async_drop, impl_trait_in_assoc_type, async_closure)]
#![feature(async_drop, impl_trait_in_assoc_type)]
#![allow(incomplete_features, dead_code)]
// FIXME(zetanumbers): consider AsyncDestruct::async_drop cleanup tests

2
tests/codegen/async-closure-debug.rs
View file

@ -7,8 +7,6 @@
// CHECK-DAG: [[CLOSURE:!.*]] = !DICompositeType(tag: DW_TAG_structure_type, name: "{closure_env#0}", scope: [[GEN_FN]]
// CHECK-DAG: [[UPVAR:!.*]] = !DIDerivedType(tag: DW_TAG_member, name: "upvar", scope: [[CLOSURE]]
#![feature(async_closure)]
fn async_closure_test(upvar: &str) -> impl AsyncFn() + '_ {
async move || {
let hello = String::from("hello");

24
tests/coverage/async_closure.cov-map
View file

@ -1,56 +1,56 @@
Function name: async_closure::call_once::<async_closure::main::{closure#0}>
Raw bytes (9): 0x[01, 01, 00, 01, 01, 07, 01, 00, 2b]
Raw bytes (9): 0x[01, 01, 00, 01, 01, 06, 01, 00, 2b]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 7, 1) to (start + 0, 43)
- Code(Counter(0)) at (prev + 6, 1) to (start + 0, 43)
Highest counter ID seen: c0
Function name: async_closure::call_once::<async_closure::main::{closure#0}>::{closure#0}
Raw bytes (14): 0x[01, 01, 00, 02, 01, 07, 2b, 01, 0e, 05, 02, 01, 00, 02]
Raw bytes (14): 0x[01, 01, 00, 02, 01, 06, 2b, 01, 0e, 05, 02, 01, 00, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 7, 43) to (start + 1, 14)
- Code(Counter(0)) at (prev + 6, 43) to (start + 1, 14)
- Code(Counter(1)) at (prev + 2, 1) to (start + 0, 2)
Highest counter ID seen: c1
Function name: async_closure::main
Raw bytes (14): 0x[01, 01, 00, 02, 01, 0b, 01, 01, 16, 01, 02, 05, 02, 02]
Raw bytes (14): 0x[01, 01, 00, 02, 01, 0a, 01, 01, 16, 01, 02, 05, 02, 02]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 2
- Code(Counter(0)) at (prev + 11, 1) to (start + 1, 22)
- Code(Counter(0)) at (prev + 10, 1) to (start + 1, 22)
- Code(Counter(0)) at (prev + 2, 5) to (start + 2, 2)
Highest counter ID seen: c0
Function name: async_closure::main::{closure#0}
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0c, 23, 00, 24]
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0b, 23, 00, 24]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 12, 35) to (start + 0, 36)
- Code(Counter(0)) at (prev + 11, 35) to (start + 0, 36)
Highest counter ID seen: c0
Function name: async_closure::main::{closure#0}::{closure#0}::<i16>
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0c, 22, 00, 24]
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0b, 22, 00, 24]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 12, 34) to (start + 0, 36)
- Code(Counter(0)) at (prev + 11, 34) to (start + 0, 36)
Highest counter ID seen: c0
Function name: async_closure::main::{closure#0}::{closure#1}::<i32>
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0c, 23, 00, 24]
Raw bytes (9): 0x[01, 01, 00, 01, 01, 0b, 23, 00, 24]
Number of files: 1
- file 0 => global file 1
Number of expressions: 0
Number of file 0 mappings: 1
- Code(Counter(0)) at (prev + 12, 35) to (start + 0, 36)
- Code(Counter(0)) at (prev + 11, 35) to (start + 0, 36)
Highest counter ID seen: c0

1
tests/coverage/async_closure.coverage
View file

@ -1,4 +1,3 @@
LL| |#![feature(async_closure)]
LL| |//@ edition: 2021
LL| |
LL| |//@ aux-build: executor.rs

1
tests/coverage/async_closure.rs
View file

@ -1,4 +1,3 @@
#![feature(async_closure)]
//@ edition: 2021
//@ aux-build: executor.rs

2
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#0}.built.after.mir
View file

@ -1,6 +1,6 @@
// MIR for `main::{closure#0}::{closure#0}::{closure#0}` after built
fn main::{closure#0}::{closure#0}::{closure#0}(_1: {async closure body@$DIR/async_closure_shims.rs:54:53: 57:10}, _2: ResumeTy) -> ()
fn main::{closure#0}::{closure#0}::{closure#0}(_1: {async closure body@$DIR/async_closure_shims.rs:53:53: 56:10}, _2: ResumeTy) -> ()
yields ()
{
debug _task_context => _2;

2
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}-{closure#1}.built.after.mir
View file

@ -1,6 +1,6 @@
// MIR for `main::{closure#0}::{closure#0}::{closure#1}` after built
fn main::{closure#0}::{closure#0}::{closure#1}(_1: {async closure body@$DIR/async_closure_shims.rs:54:53: 57:10}, _2: ResumeTy) -> ()
fn main::{closure#0}::{closure#0}::{closure#1}(_1: {async closure body@$DIR/async_closure_shims.rs:53:53: 56:10}, _2: ResumeTy) -> ()
yields ()
{
debug _task_context => _2;

6
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#0}.coroutine_closure_by_move.0.mir
View file

@ -1,10 +1,10 @@
// MIR for `main::{closure#0}::{closure#0}` 0 coroutine_closure_by_move
fn main::{closure#0}::{closure#0}(_1: {async closure@$DIR/async_closure_shims.rs:54:33: 54:52}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:54:53: 57:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:54:53: 57:10};
fn main::{closure#0}::{closure#0}(_1: {async closure@$DIR/async_closure_shims.rs:53:33: 53:52}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:53:53: 56:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:53:53: 56:10};
bb0: {
_0 = {coroutine@$DIR/async_closure_shims.rs:54:53: 57:10 (#0)} { a: move _2, b: move (_1.0: i32) };
_0 = {coroutine@$DIR/async_closure_shims.rs:53:53: 56:10 (#0)} { a: move _2, b: move (_1.0: i32) };
return;
}
}

2
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#0}.built.after.mir
View file

@ -1,6 +1,6 @@
// MIR for `main::{closure#0}::{closure#1}::{closure#0}` after built
fn main::{closure#0}::{closure#1}::{closure#0}(_1: {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10}, _2: ResumeTy) -> ()
fn main::{closure#0}::{closure#1}::{closure#0}(_1: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10}, _2: ResumeTy) -> ()
yields ()
{
debug _task_context => _2;

2
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}-{closure#1}.built.after.mir
View file

@ -1,6 +1,6 @@
// MIR for `main::{closure#0}::{closure#1}::{closure#1}` after built
fn main::{closure#0}::{closure#1}::{closure#1}(_1: {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10}, _2: ResumeTy) -> ()
fn main::{closure#0}::{closure#1}::{closure#1}(_1: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10}, _2: ResumeTy) -> ()
yields ()
{
debug _task_context => _2;

6
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_move.0.mir
View file

@ -1,10 +1,10 @@
// MIR for `main::{closure#0}::{closure#1}` 0 coroutine_closure_by_move
fn main::{closure#0}::{closure#1}(_1: {async closure@$DIR/async_closure_shims.rs:63:33: 63:47}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10};
fn main::{closure#0}::{closure#1}(_1: {async closure@$DIR/async_closure_shims.rs:62:33: 62:47}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10};
bb0: {
_0 = {coroutine@$DIR/async_closure_shims.rs:63:48: 66:10 (#0)} { a: move _2, b: move (_1.0: &i32) };
_0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: move (_1.0: &i32) };
return;
}
}

6
tests/mir-opt/async_closure_shims.main-{closure#0}-{closure#1}.coroutine_closure_by_ref.0.mir
View file

@ -1,10 +1,10 @@
// MIR for `main::{closure#0}::{closure#1}` 0 coroutine_closure_by_ref
fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.rs:63:33: 63:47}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:63:48: 66:10};
fn main::{closure#0}::{closure#1}(_1: &{async closure@$DIR/async_closure_shims.rs:62:33: 62:47}, _2: i32) -> {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10} {
let mut _0: {async closure body@$DIR/async_closure_shims.rs:62:48: 65:10};
bb0: {
_0 = {coroutine@$DIR/async_closure_shims.rs:63:48: 66:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) };
_0 = {coroutine@$DIR/async_closure_shims.rs:62:48: 65:10 (#0)} { a: move _2, b: copy ((*_1).0: &i32) };
return;
}
}

1
tests/mir-opt/async_closure_shims.rs
View file

@ -1,7 +1,6 @@
//@ edition:2021
// skip-filecheck
#![feature(async_closure, async_fn_traits)]
#![allow(unused)]
use std::future::Future;

2
tests/rustdoc/inline_cross/auxiliary/assoc_item_trait_bounds.rs
View file

@ -1,5 +1,3 @@
#![feature(async_closure)]
use std::ops::AsyncFnMut;
pub trait Main {

1
tests/ui/async-await/async-borrowck-escaping-closure-error.rs
View file

@ -1,6 +1,5 @@
//@ edition:2018
#![feature(async_closure)]
fn foo() -> Box<dyn std::future::Future<Output = u32>> {
let x = 0u32;
Box::new((async || x)())

2
tests/ui/async-await/async-borrowck-escaping-closure-error.stderr
View file

@ -1,5 +1,5 @@
error[E0515]: cannot return value referencing local variable `x`
--> $DIR/async-borrowck-escaping-closure-error.rs:6:5
--> $DIR/async-borrowck-escaping-closure-error.rs:5:5
|
LL | Box::new((async || x)())
| ^^^^^^^^^------------^^^

2
tests/ui/async-await/async-closure-matches-expr.rs
View file

@ -1,8 +1,6 @@
//@ build-pass
//@ edition:2018
#![feature(async_closure)]
macro_rules! match_expr {
($x:expr) => {}
}

2
tests/ui/async-await/async-closure.rs
View file

@ -6,8 +6,6 @@
//@ edition:2018
//@ aux-build:arc_wake.rs
#![feature(async_closure)]
extern crate arc_wake;
use std::pin::Pin;

2
tests/ui/async-await/async-closures/ambiguous-arg.rs
View file

@ -3,8 +3,6 @@
// Regression test for #123901. We previously ICE'd as we silently
// swallowed an in the `ExprUseVisitor`.
#![feature(async_closure)]
pub fn test(test: &u64, temp: &u64) {
async |check, a, b| {
//~^ ERROR type annotations needed

2
tests/ui/async-await/async-closures/ambiguous-arg.stderr
View file

@ -1,5 +1,5 @@
error[E0282]: type annotations needed
--> $DIR/ambiguous-arg.rs:9:25
--> $DIR/ambiguous-arg.rs:7:25
|
LL | async |check, a, b| {
| _________________________^

2
tests/ui/async-await/async-closures/arg-mismatch.rs
View file

@ -1,8 +1,6 @@
//@ aux-build:block-on.rs
//@ edition:2021
#![feature(async_closure)]
extern crate block_on;
fn main() {

4
tests/ui/async-await/async-closures/arg-mismatch.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/arg-mismatch.rs:12:11
--> $DIR/arg-mismatch.rs:10:11
|
LL | c(2usize).await;
| - ^^^^^^ expected `i32`, found `usize`
@ -7,7 +7,7 @@ LL | c(2usize).await;
| arguments to this function are incorrect
|
note: closure parameter defined here
--> $DIR/arg-mismatch.rs:10:24
--> $DIR/arg-mismatch.rs:8:24
|
LL | let c = async |x| {};
| ^

2
tests/ui/async-await/async-closures/async-fn-mut-for-async-fn.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ run-pass
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/async-fn-once-for-async-fn.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ run-pass
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/auxiliary/block-on.rs
View file

@ -1,7 +1,5 @@
//@ edition: 2021
#![feature(async_closure)]
use std::future::Future;
use std::pin::pin;
use std::task::*;

2
tests/ui/async-await/async-closures/auxiliary/foreign.rs
View file

@ -1,7 +1,5 @@
//@ edition:2021
#![feature(async_closure)]
pub fn closure() -> impl AsyncFn() {
async || { /* Don't really need to do anything here. */ }
}

2
tests/ui/async-await/async-closures/await-inference-guidance.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ run-pass
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/body-check-on-non-fnmut.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
// Make sure that we don't call `coroutine_by_move_body_def_id` query

2
tests/ui/async-await/async-closures/box-deref-in-debuginfo.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ run-pass
#![feature(async_closure)]
extern crate block_on;
pub trait Trait {

2
tests/ui/async-await/async-closures/brand.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
use std::future::Future;

2
tests/ui/async-await/async-closures/call-once-deduction.rs
View file

@ -1,7 +1,7 @@
//@ edition: 2021
//@ check-pass
#![feature(async_closure, async_fn_traits, unboxed_closures)]
#![feature(async_fn_traits, unboxed_closures)]
fn bar<F, O>(_: F)
where

2
tests/ui/async-await/async-closures/captures.rs
View file

@ -5,8 +5,6 @@
// Same as miri's `tests/pass/async-closure-captures.rs`, keep in sync
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/clone-closure.rs
View file

@ -3,8 +3,6 @@
//@ run-pass
//@ check-run-results
#![feature(async_closure)]
extern crate block_on;
async fn for_each(f: impl AsyncFnOnce(&str) + Clone) {

2
tests/ui/async-await/async-closures/closure-shim-borrowck-error.rs
View file

@ -1,7 +1,5 @@
//@ compile-flags: -Zvalidate-mir --edition=2018 --crate-type=lib -Copt-level=3
#![feature(async_closure)]
fn main() {}
fn needs_fn_mut<T>(mut x: impl FnMut() -> T) {

4
tests/ui/async-await/async-closures/closure-shim-borrowck-error.stderr
View file

@ -1,5 +1,5 @@
error[E0507]: cannot move out of `x` which is behind a mutable reference
--> $DIR/closure-shim-borrowck-error.rs:12:18
--> $DIR/closure-shim-borrowck-error.rs:10:18
|
LL | needs_fn_mut(async || {
| ^^^^^^^^ `x` is moved here
@ -11,7 +11,7 @@ LL | x.hello();
| move occurs because `x` has type `Ty`, which does not implement the `Copy` trait
|
note: if `Ty` implemented `Clone`, you could clone the value
--> $DIR/closure-shim-borrowck-error.rs:18:1
--> $DIR/closure-shim-borrowck-error.rs:16:1
|
LL | x.hello();
| - you could clone this value

2
tests/ui/async-await/async-closures/constrained-but-no-upvars-yet.rs
View file

@ -4,8 +4,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(async_closure)]
fn constrain<T: AsyncFnOnce()>(t: T) -> T {
t
}

2
tests/ui/async-await/async-closures/debuginfo-by-move-body.rs
View file

@ -3,8 +3,6 @@
//@ build-pass
//@ compile-flags: -Cdebuginfo=2
#![feature(async_closure)]
extern crate block_on;
async fn call_once(f: impl AsyncFnOnce()) {

2
tests/ui/async-await/async-closures/def-path.rs
View file

@ -1,8 +1,6 @@
//@ compile-flags: -Zverbose-internals
//@ edition:2021
#![feature(async_closure)]
fn main() {
let x = async || {};
//~^ NOTE the expected `async` closure body

2
tests/ui/async-await/async-closures/def-path.stderr
View file

@ -1,5 +1,5 @@
error[E0308]: mismatched types
--> $DIR/def-path.rs:9:9
--> $DIR/def-path.rs:7:9
|
LL | let x = async || {};
| -- the expected `async` closure body

2
tests/ui/async-await/async-closures/different-projection-lengths-for-different-upvars.rs
View file

@ -2,8 +2,6 @@
//@ edition: 2021
// issue: rust-lang/rust#123697
#![feature(async_closure)]
struct S { t: i32 }
fn test(s: &S, t: &i32) {

2
tests/ui/async-await/async-closures/dont-ice-when-body-tainted-by-errors.rs
View file

@ -1,7 +1,5 @@
//@ edition: 2021
#![feature(async_closure)]
struct DropMe;
trait Impossible {}

6
tests/ui/async-await/async-closures/dont-ice-when-body-tainted-by-errors.stderr
View file

@ -1,16 +1,16 @@
error[E0277]: the trait bound `(): Impossible` is not satisfied
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:19:23
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:17:23
|
LL | trait_error::<()>();
| ^^ the trait `Impossible` is not implemented for `()`
|
help: this trait has no implementations, consider adding one
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:7:1
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:5:1
|
LL | trait Impossible {}
| ^^^^^^^^^^^^^^^^
note: required by a bound in `trait_error`
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:8:19
--> $DIR/dont-ice-when-body-tainted-by-errors.rs:6:19
|
LL | fn trait_error<T: Impossible>() {}
| ^^^^^^^^^^ required by this bound in `trait_error`

1
tests/ui/async-await/async-closures/drop.rs
View file

@ -3,7 +3,6 @@
//@ run-pass
//@ check-run-results
#![feature(async_closure)]
#![allow(unused)]
extern crate block_on;

2
tests/ui/async-await/async-closures/fn-exception-target-features.rs
View file

@ -1,7 +1,7 @@
//@ edition: 2021
//@ only-x86_64
#![feature(async_closure, target_feature_11)]
#![feature(target_feature_11)]
// `target_feature_11` just to test safe functions w/ target features.
use std::pin::Pin;

2
tests/ui/async-await/async-closures/fn-exception.rs
View file

@ -1,7 +1,5 @@
//@ edition: 2021
#![feature(async_closure)]
use std::pin::Pin;
use std::future::Future;

8
tests/ui/async-await/async-closures/fn-exception.stderr
View file

@ -1,5 +1,5 @@
error[E0277]: the trait bound `unsafe fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {unsafety}: AsyncFn()` is not satisfied
--> $DIR/fn-exception.rs:19:10
--> $DIR/fn-exception.rs:17:10
|
LL | test(unsafety);
| ---- ^^^^^^^^ the trait `AsyncFn()` is not implemented for fn item `unsafe fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {unsafety}`
@ -7,13 +7,13 @@ LL | test(unsafety);
| required by a bound introduced by this call
|
note: required by a bound in `test`
--> $DIR/fn-exception.rs:16:17
--> $DIR/fn-exception.rs:14:17
|
LL | fn test(f: impl AsyncFn()) {}
| ^^^^^^^^^ required by this bound in `test`
error[E0277]: the trait bound `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}: AsyncFn()` is not satisfied
--> $DIR/fn-exception.rs:20:10
--> $DIR/fn-exception.rs:18:10
|
LL | test(abi);
| ---- ^^^ the trait `AsyncFn()` is not implemented for fn item `extern "C" fn() -> Pin<Box<(dyn Future<Output = ()> + 'static)>> {abi}`
@ -21,7 +21,7 @@ LL | test(abi);
| required by a bound introduced by this call
|
note: required by a bound in `test`
--> $DIR/fn-exception.rs:16:17
--> $DIR/fn-exception.rs:14:17
|
LL | fn test(f: impl AsyncFn()) {}
| ^^^^^^^^^ required by this bound in `test`

2
tests/ui/async-await/async-closures/force-move-due-to-actually-fnonce.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
fn consume(_: String) {}

2
tests/ui/async-await/async-closures/force-move-due-to-inferred-kind.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
fn force_fnonce<T: AsyncFnOnce()>(t: T) -> T { t }

2
tests/ui/async-await/async-closures/foreign.rs
View file

@ -3,8 +3,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
use std::future::Future;
extern crate block_on;

2
tests/ui/async-await/async-closures/higher-ranked-return.rs
View file

@ -4,8 +4,6 @@
//@ known-bug: unknown
// Borrow checking doesn't like that higher-ranked output...
#![feature(async_closure)]
extern crate block_on;
fn main() {

4
tests/ui/async-await/async-closures/higher-ranked-return.stderr
View file

@ -1,10 +1,10 @@
error: lifetime may not live long enough
--> $DIR/higher-ranked-return.rs:13:46
--> $DIR/higher-ranked-return.rs:11:46
|
LL | let x = async move |x: &str| -> &str {
| ________________________________-________----_^
| | | |
| | | return type of async closure `{async closure body@$DIR/higher-ranked-return.rs:13:46: 15:10}` contains a lifetime `'2`
| | | return type of async closure `{async closure body@$DIR/higher-ranked-return.rs:11:46: 13:10}` contains a lifetime `'2`
| | let's call the lifetime of this reference `'1`
LL | | x
LL | | };

2
tests/ui/async-await/async-closures/higher-ranked.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/implements-fnmut.rs
View file

@ -7,8 +7,6 @@
// `should_reborrow_from_env_of_parent_coroutine_closure` for more detail for when we
// must borrow from the closure env.
#![feature(async_closure)]
fn main() {
hello(&Ty);
}

2
tests/ui/async-await/async-closures/inline-body.rs
View file

@ -6,8 +6,6 @@
// `mir_inliner_callees` for the synthetic by-move coroutine body since
// its def-id wasn't previously being considered.
#![feature(async_closure)]
use std::future::Future;
use std::pin::pin;
use std::task::*;

2
tests/ui/async-await/async-closures/is-fn.rs
View file

@ -5,8 +5,6 @@
//@ ignore-compare-mode-next-solver (explicit revisions)
//@[next] compile-flags: -Znext-solver
#![feature(async_closure)]
use std::future::Future;
extern crate block_on;

4
tests/ui/async-await/async-closures/is-not-fn.rs
View file

@ -1,9 +1,7 @@
//@ edition:2021
#![feature(async_closure)]
fn main() {
fn needs_fn(x: impl FnOnce()) {}
needs_fn(async || {});
//~^ ERROR expected `{async closure@is-not-fn.rs:7:14}` to be a closure that returns `()`
//~^ ERROR expected `{async closure@is-not-fn.rs:5:14}` to be a closure that returns `()`
}

8
tests/ui/async-await/async-closures/is-not-fn.stderr
View file

@ -1,5 +1,5 @@
error[E0271]: expected `{async closure@is-not-fn.rs:7:14}` to be a closure that returns `()`, but it returns `{async closure body@$DIR/is-not-fn.rs:7:23: 7:25}`
--> $DIR/is-not-fn.rs:7:14
error[E0271]: expected `{async closure@is-not-fn.rs:5:14}` to be a closure that returns `()`, but it returns `{async closure body@$DIR/is-not-fn.rs:5:23: 5:25}`
--> $DIR/is-not-fn.rs:5:14
|
LL | needs_fn(async || {});
| -------- ^^^^^^^^^^^ expected `()`, found `async` closure body
@ -7,9 +7,9 @@ LL | needs_fn(async || {});
| required by a bound introduced by this call
|
= note: expected unit type `()`
found `async` closure body `{async closure body@$DIR/is-not-fn.rs:7:23: 7:25}`
found `async` closure body `{async closure body@$DIR/is-not-fn.rs:5:23: 5:25}`
note: required by a bound in `needs_fn`
--> $DIR/is-not-fn.rs:6:25
--> $DIR/is-not-fn.rs:4:25
|
LL | fn needs_fn(x: impl FnOnce()) {}
| ^^^^^^^^ required by this bound in `needs_fn`

1
tests/ui/async-await/async-closures/lint-closure-returning-async-block.rs
View file

@ -1,6 +1,5 @@
//@ edition: 2021
#![feature(async_closure)]
#![deny(closure_returning_async_block)]
fn main() {

12
tests/ui/async-await/async-closures/lint-closure-returning-async-block.stderr
View file

@ -1,11 +1,11 @@
error: closure returning async block can be made into an async closure
--> $DIR/lint-closure-returning-async-block.rs:7:13
--> $DIR/lint-closure-returning-async-block.rs:6:13
|
LL | let x = || async {};
| ^^ ----- this async block can be removed, and the closure can be turned into an async closure
|
note: the lint level is defined here
--> $DIR/lint-closure-returning-async-block.rs:4:9
--> $DIR/lint-closure-returning-async-block.rs:3:9
|
LL | #![deny(closure_returning_async_block)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -16,7 +16,7 @@ LL + let x = async || {};
|
error: closure returning async block can be made into an async closure
--> $DIR/lint-closure-returning-async-block.rs:10:13
--> $DIR/lint-closure-returning-async-block.rs:9:13
|
LL | let x = || async move {};
| ^^ ---------- this async block can be removed, and the closure can be turned into an async closure
@ -28,7 +28,7 @@ LL + let x = async || {};
|
error: closure returning async block can be made into an async closure
--> $DIR/lint-closure-returning-async-block.rs:13:13
--> $DIR/lint-closure-returning-async-block.rs:12:13
|
LL | let x = move || async move {};
| ^^^^^^^ ---------- this async block can be removed, and the closure can be turned into an async closure
@ -40,7 +40,7 @@ LL + let x = async move || {};
|
error: closure returning async block can be made into an async closure
--> $DIR/lint-closure-returning-async-block.rs:16:13
--> $DIR/lint-closure-returning-async-block.rs:15:13
|
LL | let x = move || async {};
| ^^^^^^^ ----- this async block can be removed, and the closure can be turned into an async closure
@ -52,7 +52,7 @@ LL + let x = async move || {};
|
error: closure returning async block can be made into an async closure
--> $DIR/lint-closure-returning-async-block.rs:19:13
--> $DIR/lint-closure-returning-async-block.rs:18:13
|
LL | let x = || {{ async {} }};
| ^^ ----- this async block can be removed, and the closure can be turned into an async closure

2
tests/ui/async-await/async-closures/mac-body.rs
View file

@ -1,8 +1,6 @@
//@ edition: 2021
//@ check-pass
#![feature(async_closure)]
// Make sure we don't ICE if an async closure has a macro body.
// This happened because we were calling walk instead of visit
// in the def collector, oops!

2
tests/ui/async-await/async-closures/mangle.rs
View file

@ -5,8 +5,6 @@
//@[v0] compile-flags: -Csymbol-mangling-version=v0
//@[legacy] compile-flags: -Csymbol-mangling-version=legacy -Zunstable-options
#![feature(async_closure)]
extern crate block_on;
use std::future::Future;

2
tests/ui/async-await/async-closures/moro-example.rs
View file

@ -1,8 +1,6 @@
//@ check-pass
//@ edition: 2021
#![feature(async_closure)]
use std::future::Future;
use std::pin::Pin;
use std::{marker::PhantomData, sync::Mutex};

2
tests/ui/async-await/async-closures/move-consuming-capture.rs
View file

@ -1,8 +1,6 @@
//@ aux-build:block-on.rs
//@ edition:2021
#![feature(async_closure)]
extern crate block_on;
struct NoCopy;

4
tests/ui/async-await/async-closures/move-consuming-capture.stderr
View file

@ -1,8 +1,8 @@
error[E0382]: use of moved value: `x`
--> $DIR/move-consuming-capture.rs:17:9
--> $DIR/move-consuming-capture.rs:15:9
|
LL | let x = async move || {
| - move occurs because `x` has type `{async closure@$DIR/move-consuming-capture.rs:13:17: 13:30}`, which does not implement the `Copy` trait
| - move occurs because `x` has type `{async closure@$DIR/move-consuming-capture.rs:11:17: 11:30}`, which does not implement the `Copy` trait
...
LL | x().await;
| --- `x` moved due to this method call

2
tests/ui/async-await/async-closures/move-is-async-fn.rs
View file

@ -2,7 +2,7 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure, async_fn_traits)]
#![feature(async_fn_traits)]
extern crate block_on;

2
tests/ui/async-await/async-closures/move-out-of-ref.rs
View file

@ -1,8 +1,6 @@
//@ compile-flags: -Zvalidate-mir
//@ edition: 2021
#![feature(async_closure)]
// NOT copy.
struct Ty;

4
tests/ui/async-await/async-closures/move-out-of-ref.stderr
View file

@ -1,11 +1,11 @@
error[E0507]: cannot move out of `*x` which is behind a shared reference
--> $DIR/move-out-of-ref.rs:11:9
--> $DIR/move-out-of-ref.rs:9:9
|
LL | *x;
| ^^ move occurs because `*x` has type `Ty`, which does not implement the `Copy` trait
|
note: if `Ty` implemented `Clone`, you could clone the value
--> $DIR/move-out-of-ref.rs:7:1
--> $DIR/move-out-of-ref.rs:5:1
|
LL | struct Ty;
| ^^^^^^^^^ consider implementing `Clone` for this type

2
tests/ui/async-await/async-closures/mut-ref-reborrow.rs
View file

@ -5,8 +5,6 @@
//@[e2018] edition:2018
//@[e2021] edition:2021
#![feature(async_closure)]
extern crate block_on;
async fn call_once(f: impl AsyncFnOnce()) { f().await; }

2
tests/ui/async-await/async-closures/mutate.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ run-pass
#![feature(async_closure)]
extern crate block_on;
fn main() {

2
tests/ui/async-await/async-closures/no-borrow-from-env.rs
View file

@ -1,8 +1,6 @@
//@ edition: 2021
//@ check-pass
#![feature(async_closure)]
fn outlives<'a>(_: impl Sized + 'a) {}
async fn call_once(f: impl AsyncFnOnce()) {

2
tests/ui/async-await/async-closures/non-copy-arg-does-not-force-inner-move.rs
View file

@ -2,8 +2,6 @@
//@ edition:2021
//@ build-pass
#![feature(async_closure)]
extern crate block_on;
fn wrapper(f: impl Fn(String)) -> impl AsyncFn(String) {

2
tests/ui/async-await/async-closures/not-clone-closure.rs
View file

@ -1,7 +1,5 @@
//@ edition: 2021
#![feature(async_closure)]
struct NotClonableArg;
#[derive(Default)]
struct NotClonableReturnType;

8
tests/ui/async-await/async-closures/not-clone-closure.stderr
View file

@ -1,12 +1,12 @@
error[E0277]: the trait bound `NotClonableUpvar: Clone` is not satisfied in `{async closure@$DIR/not-clone-closure.rs:29:21: 29:34}`
--> $DIR/not-clone-closure.rs:32:15
error[E0277]: the trait bound `NotClonableUpvar: Clone` is not satisfied in `{async closure@$DIR/not-clone-closure.rs:27:21: 27:34}`
--> $DIR/not-clone-closure.rs:30:15
|
LL | not_clone.clone();
| ^^^^^ unsatisfied trait bound
|
= help: within `{async closure@$DIR/not-clone-closure.rs:29:21: 29:34}`, the trait `Clone` is not implemented for `NotClonableUpvar`
= help: within `{async closure@$DIR/not-clone-closure.rs:27:21: 27:34}`, the trait `Clone` is not implemented for `NotClonableUpvar`
note: required because it's used within this closure
--> $DIR/not-clone-closure.rs:29:21
--> $DIR/not-clone-closure.rs:27:21
|
LL | let not_clone = async move || {
| ^^^^^^^^^^^^^

2
tests/ui/async-await/async-closures/not-fn.rs
View file

@ -2,8 +2,6 @@
// FIXME(async_closures): This needs a better error message!
#![feature(async_closure)]
fn main() {
fn needs_fn<T>(_: impl FnMut() -> T) {}

4
tests/ui/async-await/async-closures/not-fn.stderr
View file

@ -1,5 +1,5 @@
error: async closure does not implement `FnMut` because it captures state from its environment
--> $DIR/not-fn.rs:11:14
--> $DIR/not-fn.rs:9:14
|
LL | needs_fn(async || {
| -------- ^^^^^^^^
@ -7,7 +7,7 @@ LL | needs_fn(async || {
| required by a bound introduced by this call
|
note: required by a bound in `needs_fn`
--> $DIR/not-fn.rs:8:28
--> $DIR/not-fn.rs:6:28
|
LL | fn needs_fn<T>(_: impl FnMut() -> T) {}
| ^^^^^^^^^^^^ required by this bound in `needs_fn`

Some files were not shown because too many files have changed in this diff Show more