[rustc.git] / src / test / ui / async-await / drop-order / drop-order-for-async-fn-parameters-by-ref-binding.rs

// aux-build:arc_wake.rs
// edition:2018
// run-pass

#![allow(unused_variables)]

// 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()),
            )
        },
    );
}
Commit	Line	Data
48663c56 XL	1	// aux-build:arc_wake.rs
	2	// edition:2018
	3	// run-pass
	4
	5	#![allow(unused_variables)]
48663c56 XL	6
	7	// Test that the drop order for parameters in a fn and async fn matches up. Also test that
	8	// parameters (used or unused) are not dropped until the async fn completes execution.
	9	// See also #54716.
	10
	11	extern crate arc_wake;
	12
	13	use arc_wake::ArcWake;
	14	use std::cell::RefCell;
	15	use std::future::Future;
	16	use std::marker::PhantomData;
	17	use std::sync::Arc;
	18	use std::rc::Rc;
	19	use std::task::Context;
	20
	21	struct EmptyWaker;
	22
	23	impl ArcWake for EmptyWaker {
	24	fn wake(self: Arc<Self>) {}
	25	}
	26
	27	#[derive(Debug, Eq, PartialEq)]
	28	enum DropOrder {
	29	Function,
	30	Val(&'static str),
	31	}
	32
	33	type DropOrderListPtr = Rc<RefCell<Vec<DropOrder>>>;
	34
	35	struct D(&'static str, DropOrderListPtr);
	36
	37	impl Drop for D {
	38	fn drop(&mut self) {
	39	self.1.borrow_mut().push(DropOrder::Val(self.0));
	40	}
	41	}
	42
	43	/// Check that unused bindings are dropped after the function is polled.
	44	async fn foo_async(ref mut x: D, ref mut _y: D) {
	45	x.1.borrow_mut().push(DropOrder::Function);
	46	}
	47
	48	fn foo_sync(ref mut x: D, ref mut _y: D) {
	49	x.1.borrow_mut().push(DropOrder::Function);
	50	}
	51
	52	/// Check that underscore patterns are dropped after the function is polled.
	53	async fn bar_async(ref mut x: D, _: D) {
	54	x.1.borrow_mut().push(DropOrder::Function);
	55	}
	56
	57	fn bar_sync(ref mut x: D, _: D) {
	58	x.1.borrow_mut().push(DropOrder::Function);
	59	}
	60
	61	/// Check that underscore patterns within more complex patterns are dropped after the function
	62	/// is polled.
	63	async fn baz_async((ref mut x, _): (D, D)) {
	64	x.1.borrow_mut().push(DropOrder::Function);
	65	}
	66
	67	fn baz_sync((ref mut x, _): (D, D)) {
	68	x.1.borrow_mut().push(DropOrder::Function);
	69	}
70
71	/// Check that underscore and unused bindings within and outwith more complex patterns are dropped
72	/// after the function is polled.
73	async fn foobar_async(ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D) {
74	x.1.borrow_mut().push(DropOrder::Function);
75	}
76
77	fn foobar_sync(ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D) {
78	x.1.borrow_mut().push(DropOrder::Function);
79	}
80
81	struct Foo;
82
83	impl Foo {
84	/// Check that unused bindings are dropped after the method is polled.
85	async fn foo_async(ref mut x: D, ref mut _y: D) {
86	x.1.borrow_mut().push(DropOrder::Function);
87	}
88
89	fn foo_sync(ref mut x: D, ref mut _y: D) {
90	x.1.borrow_mut().push(DropOrder::Function);
91	}
92
93	/// Check that underscore patterns are dropped after the method is polled.
94	async fn bar_async(ref mut x: D, _: D) {
95	x.1.borrow_mut().push(DropOrder::Function);
96	}
97
98	fn bar_sync(ref mut x: D, _: D) {
99	x.1.borrow_mut().push(DropOrder::Function);
100	}
101
102	/// Check that underscore patterns within more complex patterns are dropped after the method
103	/// is polled.
104	async fn baz_async((ref mut x, _): (D, D)) {
105	x.1.borrow_mut().push(DropOrder::Function);
106	}
107
108	fn baz_sync((ref mut x, _): (D, D)) {
109	x.1.borrow_mut().push(DropOrder::Function);
110	}
111
112	/// Check that underscore and unused bindings within and outwith more complex patterns are
113	/// dropped after the method is polled.
114	async fn foobar_async(
115	ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
116	) {
117	x.1.borrow_mut().push(DropOrder::Function);
118	}
119
120	fn foobar_sync(
121	ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
122	) {
123	x.1.borrow_mut().push(DropOrder::Function);
124	}
125	}
126
127	struct Bar<'a>(PhantomData<&'a ()>);
128
129	impl<'a> Bar<'a> {
130	/// Check that unused bindings are dropped after the method with self is polled.
131	async fn foo_async(&'a self, ref mut x: D, ref mut _y: D) {
132	x.1.borrow_mut().push(DropOrder::Function);
133	}
134
135	fn foo_sync(&'a self, ref mut x: D, ref mut _y: D) {
136	x.1.borrow_mut().push(DropOrder::Function);
137	}
138
139	/// Check that underscore patterns are dropped after the method with self is polled.
140	async fn bar_async(&'a self, ref mut x: D, _: D) {
141	x.1.borrow_mut().push(DropOrder::Function);
142	}
143
144	fn bar_sync(&'a self, ref mut x: D, _: D) {
145	x.1.borrow_mut().push(DropOrder::Function);
146	}
147
148	/// Check that underscore patterns within more complex patterns are dropped after the method
149	/// with self is polled.
150	async fn baz_async(&'a self, (ref mut x, _): (D, D)) {
151	x.1.borrow_mut().push(DropOrder::Function);
152	}
153
154	fn baz_sync(&'a self, (ref mut x, _): (D, D)) {
155	x.1.borrow_mut().push(DropOrder::Function);
156	}
157
158	/// Check that underscore and unused bindings within and outwith more complex patterns are
159	/// dropped after the method with self is polled.
160	async fn foobar_async(
161	&'a self, ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
162	) {
163	x.1.borrow_mut().push(DropOrder::Function);
164	}
165
166	fn foobar_sync(
167	&'a self, ref mut x: D, (ref mut a, _, ref mut _c): (D, D, D), _: D, ref mut _y: D,
168	) {
169	x.1.borrow_mut().push(DropOrder::Function);
170	}
171	}
172
173	fn assert_drop_order_after_poll<Fut: Future<Output = ()>>(
174	f: impl FnOnce(DropOrderListPtr) -> Fut,
175	g: impl FnOnce(DropOrderListPtr),
176	) {
177	let empty = Arc::new(EmptyWaker);
178	let waker = ArcWake::into_waker(empty);
179	let mut cx = Context::from_waker(&waker);
180
181	let actual_order = Rc::new(RefCell::new(Vec::new()));
182	let mut fut = Box::pin(f(actual_order.clone()));
183	let _ = fut.as_mut().poll(&mut cx);
184
185	let expected_order = Rc::new(RefCell::new(Vec::new()));
186	g(expected_order.clone());
187
188	assert_eq!(actual_order.borrow(), expected_order.borrow());
189	}
190
191	fn main() {
192	// Free functions (see doc comment on function for what it tests).
193	assert_drop_order_after_poll(\|l\| foo_async(D("x", l.clone()), D("_y", l.clone())),
194	\|l\| foo_sync(D("x", l.clone()), D("_y", l.clone())));
195	assert_drop_order_after_poll(\|l\| bar_async(D("x", l.clone()), D("_", l.clone())),
196	\|l\| bar_sync(D("x", l.clone()), D("_", l.clone())));
197	assert_drop_order_after_poll(\|l\| baz_async((D("x", l.clone()), D("_", l.clone()))),
198	\|l\| baz_sync((D("x", l.clone()), D("_", l.clone()))));
199	assert_drop_order_after_poll(
200	\|l\| {
201	foobar_async(
202	D("x", l.clone()),
203	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
204	D("_", l.clone()),
205	D("_y", l.clone()),
206	)
207	},
208	\|l\| {
209	foobar_sync(
210	D("x", l.clone()),
211	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
212	D("_", l.clone()),
213	D("_y", l.clone()),
214	)
215	},
216	);
217
218	// Methods w/out self (see doc comment on function for what it tests).
219	assert_drop_order_after_poll(\|l\| Foo::foo_async(D("x", l.clone()), D("_y", l.clone())),
220	\|l\| Foo::foo_sync(D("x", l.clone()), D("_y", l.clone())));
221	assert_drop_order_after_poll(\|l\| Foo::bar_async(D("x", l.clone()), D("_", l.clone())),
222	\|l\| Foo::bar_sync(D("x", l.clone()), D("_", l.clone())));
223	assert_drop_order_after_poll(\|l\| Foo::baz_async((D("x", l.clone()), D("_", l.clone()))),
224	\|l\| Foo::baz_sync((D("x", l.clone()), D("_", l.clone()))));
225	assert_drop_order_after_poll(
226	\|l\| {
227	Foo::foobar_async(
228	D("x", l.clone()),
229	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
230	D("_", l.clone()),
231	D("_y", l.clone()),
232	)
233	},
234	\|l\| {
235	Foo::foobar_sync(
236	D("x", l.clone()),
237	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
238	D("_", l.clone()),
239	D("_y", l.clone()),
240	)
241	},
242	);
243
244	// Methods (see doc comment on function for what it tests).
245	let b = Bar(Default::default());
246	assert_drop_order_after_poll(\|l\| b.foo_async(D("x", l.clone()), D("_y", l.clone())),
247	\|l\| b.foo_sync(D("x", l.clone()), D("_y", l.clone())));
248	assert_drop_order_after_poll(\|l\| b.bar_async(D("x", l.clone()), D("_", l.clone())),
249	\|l\| b.bar_sync(D("x", l.clone()), D("_", l.clone())));
250	assert_drop_order_after_poll(\|l\| b.baz_async((D("x", l.clone()), D("_", l.clone()))),
251	\|l\| b.baz_sync((D("x", l.clone()), D("_", l.clone()))));
252	assert_drop_order_after_poll(
253	\|l\| {
254	b.foobar_async(
255	D("x", l.clone()),
256	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
257	D("_", l.clone()),
258	D("_y", l.clone()),
259	)
260	},
261	\|l\| {
262	b.foobar_sync(
263	D("x", l.clone()),
264	(D("a", l.clone()), D("_", l.clone()), D("_c", l.clone())),
265	D("_", l.clone()),
266	D("_y", l.clone()),
267	)
268	},
269	);
270	}