Rollup merge of #60535 - taiki-e:async-fn-arguments, r=cramertj
Correct handling of arguments in async fn Fixes #60509 Fixes #60566 r? @cramertj or @davidtwco
This commit is contained in:
Mazdak Farrokhzad
GitHub
commit
535db2f357
6 changed files with 341 additions and 22 deletions
|
|
@ -1576,7 +1576,7 @@ impl<'a> Parser<'a> {
|
|||
let ident = self.parse_ident()?;
|
||||
let mut generics = self.parse_generics()?;
|
||||
|
||||
let d = self.parse_fn_decl_with_self(|p: &mut Parser<'a>| {
|
||||
let mut decl = self.parse_fn_decl_with_self(|p: &mut Parser<'a>| {
|
||||
// This is somewhat dubious; We don't want to allow
|
||||
// argument names to be left off if there is a
|
||||
// definition...
|
||||
|
|
@ -1585,7 +1585,7 @@ impl<'a> Parser<'a> {
|
|||
p.parse_arg_general(p.span.rust_2018(), true, false)
|
||||
})?;
|
||||
generics.where_clause = self.parse_where_clause()?;
|
||||
self.construct_async_arguments(&mut asyncness, &d);
|
||||
self.construct_async_arguments(&mut asyncness, &mut decl);
|
||||
|
||||
let sig = ast::MethodSig {
|
||||
header: FnHeader {
|
||||
|
|
@ -1594,7 +1594,7 @@ impl<'a> Parser<'a> {
|
|||
abi,
|
||||
asyncness,
|
||||
},
|
||||
decl: d,
|
||||
decl,
|
||||
};
|
||||
|
||||
let body = match self.token {
|
||||
|
|
@ -6475,10 +6475,10 @@ impl<'a> Parser<'a> {
|
|||
-> PResult<'a, ItemInfo> {
|
||||
let (ident, mut generics) = self.parse_fn_header()?;
|
||||
let allow_c_variadic = abi == Abi::C && unsafety == Unsafety::Unsafe;
|
||||
let decl = self.parse_fn_decl(allow_c_variadic)?;
|
||||
let mut decl = self.parse_fn_decl(allow_c_variadic)?;
|
||||
generics.where_clause = self.parse_where_clause()?;
|
||||
let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
|
||||
self.construct_async_arguments(&mut asyncness, &decl);
|
||||
self.construct_async_arguments(&mut asyncness, &mut decl);
|
||||
let header = FnHeader { unsafety, asyncness, constness, abi };
|
||||
Ok((ident, ItemKind::Fn(decl, header, generics, body), Some(inner_attrs)))
|
||||
}
|
||||
|
|
@ -6662,9 +6662,9 @@ impl<'a> Parser<'a> {
|
|||
let (constness, unsafety, mut asyncness, abi) = self.parse_fn_front_matter()?;
|
||||
let ident = self.parse_ident()?;
|
||||
let mut generics = self.parse_generics()?;
|
||||
let decl = self.parse_fn_decl_with_self(|p| p.parse_arg())?;
|
||||
let mut decl = self.parse_fn_decl_with_self(|p| p.parse_arg())?;
|
||||
generics.where_clause = self.parse_where_clause()?;
|
||||
self.construct_async_arguments(&mut asyncness, &decl);
|
||||
self.construct_async_arguments(&mut asyncness, &mut decl);
|
||||
*at_end = true;
|
||||
let (inner_attrs, body) = self.parse_inner_attrs_and_block()?;
|
||||
let header = ast::FnHeader { abi, unsafety, constness, asyncness };
|
||||
|
|
@ -8710,9 +8710,9 @@ impl<'a> Parser<'a> {
|
|||
///
|
||||
/// The arguments of the function are replaced in HIR lowering with the arguments created by
|
||||
/// this function and the statements created here are inserted at the top of the closure body.
|
||||
fn construct_async_arguments(&mut self, asyncness: &mut Spanned<IsAsync>, decl: &FnDecl) {
|
||||
fn construct_async_arguments(&mut self, asyncness: &mut Spanned<IsAsync>, decl: &mut FnDecl) {
|
||||
if let IsAsync::Async { ref mut arguments, .. } = asyncness.node {
|
||||
for (index, input) in decl.inputs.iter().enumerate() {
|
||||
for (index, input) in decl.inputs.iter_mut().enumerate() {
|
||||
let id = ast::DUMMY_NODE_ID;
|
||||
let span = input.pat.span;
|
||||
|
||||
|
|
@ -8724,8 +8724,10 @@ impl<'a> Parser<'a> {
|
|||
// `let <pat> = __argN;` statement, instead just adding a `let <pat> = <pat>;`
|
||||
// statement.
|
||||
let (binding_mode, ident, is_simple_pattern) = match input.pat.node {
|
||||
PatKind::Ident(binding_mode, ident, _) => (binding_mode, ident, true),
|
||||
_ => (BindingMode::ByValue(Mutability::Immutable), ident, false),
|
||||
PatKind::Ident(binding_mode @ BindingMode::ByValue(_), ident, _) => {
|
||||
(binding_mode, ident, true)
|
||||
}
|
||||
_ => (BindingMode::ByValue(Mutability::Mutable), ident, false),
|
||||
};
|
||||
|
||||
// Construct an argument representing `__argN: <ty>` to replace the argument of the
|
||||
|
|
@ -8792,6 +8794,15 @@ impl<'a> Parser<'a> {
|
|||
})
|
||||
};
|
||||
|
||||
// Remove mutability from arguments. If this is not a simple pattern,
|
||||
// those arguments are replaced by `__argN`, so there is no need to do this.
|
||||
if let PatKind::Ident(BindingMode::ByValue(mutability @ Mutability::Mutable), ..) =
|
||||
&mut input.pat.node
|
||||
{
|
||||
assert!(is_simple_pattern);
|
||||
*mutability = Mutability::Immutable;
|
||||
}
|
||||
|
||||
let move_stmt = Stmt { id, node: StmtKind::Local(P(move_local)), span };
|
||||
arguments.push(AsyncArgument { ident, arg, pat_stmt, move_stmt });
|
||||
}
|
||||
|
|
|
|||
30
src/test/ui/async-await/argument-patterns.rs
Normal file
30
src/test/ui/async-await/argument-patterns.rs
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
// edition:2018
|
||||
// run-pass
|
||||
|
||||
#![allow(unused_variables)]
|
||||
#![deny(unused_mut)]
|
||||
#![feature(async_await)]
|
||||
|
||||
type A = Vec<u32>;
|
||||
|
||||
async fn a(n: u32, mut vec: A) {
|
||||
vec.push(n);
|
||||
}
|
||||
|
||||
async fn b(n: u32, ref mut vec: A) {
|
||||
vec.push(n);
|
||||
}
|
||||
|
||||
async fn c(ref vec: A) {
|
||||
vec.contains(&0);
|
||||
}
|
||||
|
||||
async fn d((a, mut b): (A, A)) {
|
||||
b.push(1);
|
||||
}
|
||||
|
||||
async fn f((ref mut a, ref b): (A, A)) {}
|
||||
|
||||
async fn g(((ref a, ref mut b), (ref mut c, ref d)): ((A, A), (A, A))) {}
|
||||
|
||||
fn main() {}
|
||||
|
|
@ -0,0 +1,271 @@
|
|||
// aux-build:arc_wake.rs
|
||||
// edition:2018
|
||||
// run-pass
|
||||
|
||||
#![allow(unused_variables)]
|
||||
#![feature(async_await, await_macro)]
|
||||
|
||||
// Test that the drop order for parameters in a fn and async fn matches up. Also test that
|
||||
// parameters (used or unused) are not dropped until the async fn completes execution.
|
||||
// See also #54716.
|
||||
|
||||
extern crate arc_wake;
|
||||
|
||||
use arc_wake::ArcWake;
|
||||
use std::cell::RefCell;
|
||||
use std::future::Future;
|
||||
use std::marker::PhantomData;
|
||||
use std::sync::Arc;
|
||||
use std::rc::Rc;
|
||||
use std::task::Context;
|
||||
|
||||
struct EmptyWaker;
|
||||
|
||||
impl ArcWake for EmptyWaker {
|
||||
fn wake(self: Arc<Self>) {}
|
||||
}
|
||||
|
||||
#[derive(Debug, Eq, PartialEq)]
|
||||
enum DropOrder {
|
||||
Function,
|
||||
Val(&'static str),
|
||||
}
|
||||
|
||||
type DropOrderListPtr = Rc<RefCell<Vec<DropOrder>>>;
|
||||
|
||||
struct D(&'static str, DropOrderListPtr);
|
||||
|
||||
impl Drop for D {
|
||||
fn drop(&mut self) {
|
||||
self.1.borrow_mut().push(DropOrder::Val(self.0));
|
||||
}
|
||||
}
|
||||
|
||||
/// Check that unused bindings are dropped after the function is polled.
|
||||
async fn foo_async(ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foo_sync(ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns are dropped after the function is polled.
|
||||
async fn bar_async(ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn bar_sync(ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns within more complex patterns are dropped after the function
|
||||
/// is polled.
|
||||
async fn baz_async((ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn baz_sync((ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore and unused bindings within and outwith more complex patterns are dropped
|
||||
/// after the function is polled.
|
||||
async fn foobar_async(ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foobar_sync(ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
struct Foo;
|
||||
|
||||
impl Foo {
|
||||
/// Check that unused bindings are dropped after the method is polled.
|
||||
async fn foo_async(ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foo_sync(ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns are dropped after the method is polled.
|
||||
async fn bar_async(ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn bar_sync(ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns within more complex patterns are dropped after the method
|
||||
/// is polled.
|
||||
async fn baz_async((ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn baz_sync((ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore and unused bindings within and outwith more complex patterns are
|
||||
/// dropped after the method is polled.
|
||||
async fn foobar_async(
|
||||
ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
|
||||
) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foobar_sync(
|
||||
ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
|
||||
) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
}
|
||||
|
||||
struct Bar<'a>(PhantomData<&'a ()>);
|
||||
|
||||
impl<'a> Bar<'a> {
|
||||
/// Check that unused bindings are dropped after the method with self is polled.
|
||||
async fn foo_async(&'a self, ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foo_sync(&'a self, ref mut x: D, ref mut _y: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns are dropped after the method with self is polled.
|
||||
async fn bar_async(&'a self, ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn bar_sync(&'a self, ref mut x: D, _: D) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore patterns within more complex patterns are dropped after the method
|
||||
/// with self is polled.
|
||||
async fn baz_async(&'a self, (ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn baz_sync(&'a self, (ref mut x, _): (D, D)) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
/// Check that underscore and unused bindings within and outwith more complex patterns are
|
||||
/// dropped after the method with self is polled.
|
||||
async fn foobar_async(
|
||||
&'a self, ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
|
||||
) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
|
||||
fn foobar_sync(
|
||||
&'a self, ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
|
||||
) {
|
||||
x.1.borrow_mut().push(DropOrder::Function);
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_drop_order_after_poll<Fut: Future<Output = ()>>(
|
||||
f: impl FnOnce(DropOrderListPtr) -> Fut,
|
||||
g: impl FnOnce(DropOrderListPtr),
|
||||
) {
|
||||
let empty = Arc::new(EmptyWaker);
|
||||
let waker = ArcWake::into_waker(empty);
|
||||
let mut cx = Context::from_waker(&waker);
|
||||
|
||||
let actual_order = Rc::new(RefCell::new(Vec::new()));
|
||||
let mut fut = Box::pin(f(actual_order.clone()));
|
||||
let _ = fut.as_mut().poll(&mut cx);
|
||||
|
||||
let expected_order = Rc::new(RefCell::new(Vec::new()));
|
||||
g(expected_order.clone());
|
||||
|
||||
assert_eq!(*actual_order.borrow(), *expected_order.borrow());
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// Free functions (see doc comment on function for what it tests).
|
||||
assert_drop_order_after_poll(|l| foo_async(D("x", l.clone()), D("_y", l.clone())),
|
||||
|l| foo_sync(D("x", l.clone()), D("_y", l.clone())));
|
||||
assert_drop_order_after_poll(|l| bar_async(D("x", l.clone()), D("_", l.clone())),
|
||||
|l| bar_sync(D("x", l.clone()), D("_", l.clone())));
|
||||
assert_drop_order_after_poll(|l| baz_async((D("x", l.clone()), D("_", l.clone()))),
|
||||
|l| baz_sync((D("x", l.clone()), D("_", l.clone()))));
|
||||
assert_drop_order_after_poll(
|
||||
|l| {
|
||||
foobar_async(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
|l| {
|
||||
foobar_sync(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
);
|
||||
|
||||
// Methods w/out self (see doc comment on function for what it tests).
|
||||
assert_drop_order_after_poll(|l| Foo::foo_async(D("x", l.clone()), D("_y", l.clone())),
|
||||
|l| Foo::foo_sync(D("x", l.clone()), D("_y", l.clone())));
|
||||
assert_drop_order_after_poll(|l| Foo::bar_async(D("x", l.clone()), D("_", l.clone())),
|
||||
|l| Foo::bar_sync(D("x", l.clone()), D("_", l.clone())));
|
||||
assert_drop_order_after_poll(|l| Foo::baz_async((D("x", l.clone()), D("_", l.clone()))),
|
||||
|l| Foo::baz_sync((D("x", l.clone()), D("_", l.clone()))));
|
||||
assert_drop_order_after_poll(
|
||||
|l| {
|
||||
Foo::foobar_async(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
|l| {
|
||||
Foo::foobar_sync(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
);
|
||||
|
||||
// Methods (see doc comment on function for what it tests).
|
||||
let b = Bar(Default::default());
|
||||
assert_drop_order_after_poll(|l| b.foo_async(D("x", l.clone()), D("_y", l.clone())),
|
||||
|l| b.foo_sync(D("x", l.clone()), D("_y", l.clone())));
|
||||
assert_drop_order_after_poll(|l| b.bar_async(D("x", l.clone()), D("_", l.clone())),
|
||||
|l| b.bar_sync(D("x", l.clone()), D("_", l.clone())));
|
||||
assert_drop_order_after_poll(|l| b.baz_async((D("x", l.clone()), D("_", l.clone()))),
|
||||
|l| b.baz_sync((D("x", l.clone()), D("_", l.clone()))));
|
||||
assert_drop_order_after_poll(
|
||||
|l| {
|
||||
b.foobar_async(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
|l| {
|
||||
b.foobar_sync(
|
||||
D("x", l.clone()),
|
||||
(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
|
||||
D("_", l.clone()),
|
||||
D("_y", l.clone()),
|
||||
)
|
||||
},
|
||||
);
|
||||
}
|
||||
|
|
@ -8,4 +8,9 @@ async fn foobar_async(x: u32, (a, _, _c): (u32, u32, u32), _: u32, _y: u32) {
|
|||
assert_eq!(__arg2, 4); //~ ERROR cannot find value `__arg2` in this scope [E0425]
|
||||
}
|
||||
|
||||
async fn baz_async(ref mut x: u32, ref y: u32) {
|
||||
assert_eq!(__arg0, 1); //~ ERROR cannot find value `__arg0` in this scope [E0425]
|
||||
assert_eq!(__arg1, 2); //~ ERROR cannot find value `__arg1` in this scope [E0425]
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
|
|
|
|||
|
|
@ -10,6 +10,18 @@ error[E0425]: cannot find value `__arg2` in this scope
|
|||
LL | assert_eq!(__arg2, 4);
|
||||
| ^^^^^^ not found in this scope
|
||||
|
||||
error: aborting due to 2 previous errors
|
||||
error[E0425]: cannot find value `__arg0` in this scope
|
||||
--> $DIR/drop-order-locals-are-hidden.rs:12:16
|
||||
|
|
||||
LL | assert_eq!(__arg0, 1);
|
||||
| ^^^^^^ not found in this scope
|
||||
|
||||
error[E0425]: cannot find value `__arg1` in this scope
|
||||
--> $DIR/drop-order-locals-are-hidden.rs:13:16
|
||||
|
|
||||
LL | assert_eq!(__arg1, 2);
|
||||
| ^^^^^^ not found in this scope
|
||||
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0425`.
|
||||
|
|
|
|||
|
|
@ -1,10 +0,0 @@
|
|||
// edition:2018
|
||||
// run-pass
|
||||
|
||||
#![feature(async_await)]
|
||||
|
||||
async fn foo(n: u32, mut vec: Vec<u32>) {
|
||||
vec.push(n);
|
||||
}
|
||||
|
||||
fn main() {}
|
||||
Loading…
Add table
Add a link
Reference in a new issue