mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Adjust tests. wrt. await_macro being removed.

Browse Source
This commit is contained in:
Mazdak Farrokhzad 2019-07-02 06:46:35 +02:00
parent 758931948f
commit 581f2cbfe9
11 changed files with 117 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/test/ui/async-await/await-keyword/2015-edition-error-in-non-macro-position.rs → src/test/ui/async-await/await-keyword/2015-edition-error-various-positions.rs
View File

@ -1,4 +1,4 @@
#![feature(async_await, await_macro)]
#![feature(async_await)]
#![allow(non_camel_case_types)]
#![deny(keyword_idents)]
@ -29,6 +29,9 @@ macro_rules! await {
}
fn main() {
await!(); //~ ERROR `await` is a keyword in the 2018 edition
//~^ WARN this was previously accepted by the compiler
match await { await => {} } //~ ERROR `await` is a keyword in the 2018 edition
//~^ ERROR `await` is a keyword in the 2018 edition
//~^^ WARN this was previously accepted by the compiler

31
src/test/ui/async-await/await-keyword/2015-edition-error-in-non-macro-position.stderr → src/test/ui/async-await/await-keyword/2015-edition-error-various-positions.stderr
View File

@ -1,11 +1,11 @@
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:6:13
--> $DIR/2015-edition-error-various-positions.rs:6:13
|
LL | pub mod await {
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
|
note: lint level defined here
--> $DIR/2015-edition-error-in-non-macro-position.rs:3:9
--> $DIR/2015-edition-error-various-positions.rs:3:9
|
LL | #![deny(keyword_idents)]
| ^^^^^^^^^^^^^^
@ -13,7 +13,7 @@ LL | #![deny(keyword_idents)]
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:8:20
--> $DIR/2015-edition-error-various-positions.rs:8:20
|
LL | pub struct await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -22,7 +22,7 @@ LL | pub struct await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:12:16
--> $DIR/2015-edition-error-various-positions.rs:12:16
|
LL | use outer_mod::await::await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -31,7 +31,7 @@ LL | use outer_mod::await::await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:12:23
--> $DIR/2015-edition-error-various-positions.rs:12:23
|
LL | use outer_mod::await::await;
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -40,7 +40,7 @@ LL | use outer_mod::await::await;
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:17:14
--> $DIR/2015-edition-error-various-positions.rs:17:14
|
LL | struct Foo { await: () }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -49,7 +49,7 @@ LL | struct Foo { await: () }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:21:15
--> $DIR/2015-edition-error-various-positions.rs:21:15
|
LL | impl Foo { fn await() {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -58,7 +58,7 @@ LL | impl Foo { fn await() {} }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:25:14
--> $DIR/2015-edition-error-various-positions.rs:25:14
|
LL | macro_rules! await {
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -67,7 +67,16 @@ LL | macro_rules! await {
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:32:11
--> $DIR/2015-edition-error-various-positions.rs:32:5
|
LL | await!();
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
|
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-various-positions.rs:35:11
|
LL | match await { await => {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -76,7 +85,7 @@ LL | match await { await => {} }
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: `await` is a keyword in the 2018 edition
--> $DIR/2015-edition-error-in-non-macro-position.rs:32:19
--> $DIR/2015-edition-error-various-positions.rs:35:19
|
LL | match await { await => {} }
| ^^^^^ help: you can use a raw identifier to stay compatible: `r#await`
@ -84,5 +93,5 @@ LL | match await { await => {} }
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #49716 <https://github.com/rust-lang/rust/issues/49716>
error: aborting due to 9 previous errors
error: aborting due to 10 previous errors

6
src/test/ui/async-await/await-keyword/2018-edition-error.rs
View File

@ -9,4 +9,8 @@ mod outer_mod {
use self::outer_mod::await::await; //~ ERROR expected identifier
//~^ ERROR expected identifier, found reserved keyword `await`
fn main() {}
macro_rules! await { () => {}; } //~ ERROR expected identifier, found reserved keyword `await`
fn main() {
await!(); //~ ERROR expected expression, found `)`
}

18
src/test/ui/async-await/await-keyword/2018-edition-error.stderr
View File

@ -38,5 +38,21 @@ help: you can escape reserved keywords to use them as identifiers
LL | use self::outer_mod::await::r#await;
| ^^^^^^^
error: aborting due to 4 previous errors
error: expected identifier, found reserved keyword `await`
--> $DIR/2018-edition-error.rs:12:14
|
LL | macro_rules! await { () => {}; }
| ^^^^^ expected identifier, found reserved keyword
help: you can escape reserved keywords to use them as identifiers
|
LL | macro_rules! r#await { () => {}; }
| ^^^^^^^
error: expected expression, found `)`
--> $DIR/2018-edition-error.rs:15:12
|
LL | await!();
| ^ expected expression
error: aborting due to 6 previous errors

25
src/test/ui/async-await/await-keyword/incorrect-syntax-suggestions.rs
View File

@ -104,6 +104,31 @@ fn foo25() -> Result<(), ()> {
foo()
}
async fn foo26() -> Result<(), ()> {
let _ = await!(bar()); //~ ERROR incorrect use of `await`
Ok(())
}
async fn foo27() -> Result<(), ()> {
let _ = await!(bar())?; //~ ERROR incorrect use of `await`
Ok(())
}
fn foo28() -> Result<(), ()> {
fn foo() -> Result<(), ()> {
let _ = await!(bar())?; //~ ERROR incorrect use of `await`
//~^ ERROR `await` is only allowed inside `async` functions
Ok(())
}
foo()
}
fn foo29() -> Result<(), ()> {
let foo = || {
let _ = await!(bar())?; //~ ERROR incorrect use of `await`
//~^ ERROR `await` is only allowed inside `async` functions
Ok(())
};
foo()
}
fn main() {
match await { await => () }
//~^ ERROR expected expression, found `=>`

48
src/test/ui/async-await/await-keyword/incorrect-syntax-suggestions.stderr
View File

@ -88,8 +88,32 @@ error: incorrect use of `await`
LL | let _ = bar().await()?;
| ^^ help: `await` is not a method call, remove the parentheses
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:108:13
|
LL | let _ = await!(bar());
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:112:13
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:117:17
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:125:17
|
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
error: expected expression, found `=>`
--> $DIR/incorrect-syntax-suggestions.rs:108:25
--> $DIR/incorrect-syntax-suggestions.rs:133:25
|
LL | match await { await => () }
| ----- ^^ expected expression
@ -97,13 +121,13 @@ LL | match await { await => () }
| while parsing this incorrect await expression
error: incorrect use of `await`
--> $DIR/incorrect-syntax-suggestions.rs:108:11
--> $DIR/incorrect-syntax-suggestions.rs:133:11
|
LL | match await { await => () }
| ^^^^^^^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ await => () }.await`
error: expected one of `.`, `?`, `{`, or an operator, found `}`
--> $DIR/incorrect-syntax-suggestions.rs:111:1
--> $DIR/incorrect-syntax-suggestions.rs:136:1
|
LL | match await { await => () }
| ----- - expected one of `.`, `?`, `{`, or an operator here
@ -193,6 +217,22 @@ LL | let foo = || {
LL | let _ = bar().await?;
| ^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:117:17
|
LL | fn foo() -> Result<(), ()> {
| --- this is not `async`
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0728]: `await` is only allowed inside `async` functions and blocks
--> $DIR/incorrect-syntax-suggestions.rs:125:17
|
LL | let foo = || {
| -- this is not `async`
LL | let _ = await!(bar())?;
| ^^^^^^^^^^^^^ only allowed inside `async` functions and blocks
error[E0277]: the `?` operator can only be applied to values that implement `std::ops::Try`
--> $DIR/incorrect-syntax-suggestions.rs:18:19
|
@ -202,6 +242,6 @@ LL | let _ = await bar()?;
= help: the trait `std::ops::Try` is not implemented for `impl std::future::Future`
= note: required by `std::ops::Try::into_result`
error: aborting due to 29 previous errors
error: aborting due to 35 previous errors
For more information about this error, try `rustc --explain E0277`.

4
src/test/ui/async-await/await-keyword/post_expansion_error.stderr
View File

@ -2,9 +2,7 @@ error: expected expression, found `)`
--> $DIR/post_expansion_error.rs:8:12
|
LL | await!()
| ----- ^ expected expression
| |
| while parsing this await macro call
| ^ expected expression
error: aborting due to previous error

230
src/test/ui/async-await/await-macro.rs
View File

@ -1,230 +0,0 @@
// run-pass
// edition:2018
// aux-build:arc_wake.rs
#![feature(async_await, async_closure, await_macro)]
extern crate arc_wake;
use std::pin::Pin;
use std::future::Future;
use std::sync::{
Arc,
atomic::{self, AtomicUsize},
};
use std::task::{Context, Poll};
use arc_wake::ArcWake;
struct Counter {
wakes: AtomicUsize,
}
impl ArcWake for Counter {
fn wake(self: Arc<Self>) {
Self::wake_by_ref(&self)
}
fn wake_by_ref(arc_self: &Arc<Self>) {
arc_self.wakes.fetch_add(1, atomic::Ordering::SeqCst);
}
}
struct WakeOnceThenComplete(bool);
fn wake_and_yield_once() -> WakeOnceThenComplete { WakeOnceThenComplete(false) }
impl Future for WakeOnceThenComplete {
type Output = ();
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
if self.0 {
Poll::Ready(())
} else {
cx.waker().wake_by_ref();
self.0 = true;
Poll::Pending
}
}
}
fn async_block(x: u8) -> impl Future<Output = u8> {
async move {
await!(wake_and_yield_once());
x
}
}
fn async_block_with_borrow_named_lifetime<'a>(x: &'a u8) -> impl Future<Output = u8> + 'a {
async move {
await!(wake_and_yield_once());
*x
}
}
fn async_nonmove_block(x: u8) -> impl Future<Output = u8> {
async move {
let future = async {
await!(wake_and_yield_once());
x
};
await!(future)
}
}
fn async_closure(x: u8) -> impl Future<Output = u8> {
(async move |x: u8| -> u8 {
await!(wake_and_yield_once());
x
})(x)
}
fn async_closure_in_unsafe_block(x: u8) -> impl Future<Output = u8> {
(unsafe {
async move |x: u8| unsafe_fn(await!(unsafe_async_fn(x)))
})(x)
}
async fn async_fn(x: u8) -> u8 {
await!(wake_and_yield_once());
x
}
async fn generic_async_fn<T>(x: T) -> T {
await!(wake_and_yield_once());
x
}
async fn async_fn_with_borrow(x: &u8) -> u8 {
await!(wake_and_yield_once());
*x
}
async fn async_fn_with_borrow_named_lifetime<'a>(x: &'a u8) -> u8 {
await!(wake_and_yield_once());
*x
}
fn async_fn_with_impl_future_named_lifetime<'a>(x: &'a u8) -> impl Future<Output = u8> + 'a {
async move {
await!(wake_and_yield_once());
*x
}
}
/* FIXME(cramertj) support when `existential type T<'a, 'b>:;` works
async fn async_fn_multiple_args(x: &u8, _y: &u8) -> u8 {
await!(wake_and_yield_once());
*x
}
*/
async fn async_fn_multiple_args_named_lifetime<'a>(x: &'a u8, _y: &'a u8) -> u8 {
await!(wake_and_yield_once());
*x
}
fn async_fn_with_internal_borrow(y: u8) -> impl Future<Output = u8> {
async move {
await!(async_fn_with_borrow_named_lifetime(&y))
}
}
async unsafe fn unsafe_async_fn(x: u8) -> u8 {
await!(wake_and_yield_once());
x
}
unsafe fn unsafe_fn(x: u8) -> u8 {
x
}
fn async_block_in_unsafe_block(x: u8) -> impl Future<Output = u8> {
unsafe {
async move {
unsafe_fn(await!(unsafe_async_fn(x)))
}
}
}
struct Foo;
trait Bar {
fn foo() {}
}
impl Foo {
async fn async_assoc_item(x: u8) -> u8 {
unsafe {
await!(unsafe_async_fn(x))
}
}
async unsafe fn async_unsafe_assoc_item(x: u8) -> u8 {
await!(unsafe_async_fn(x))
}
}
fn test_future_yields_once_then_returns<F, Fut>(f: F)
where
F: FnOnce(u8) -> Fut,
Fut: Future<Output = u8>,
{
let mut fut = Box::pin(f(9));
let counter = Arc::new(Counter { wakes: AtomicUsize::new(0) });
let waker = ArcWake::into_waker(counter.clone());
let mut cx = Context::from_waker(&waker);
assert_eq!(0, counter.wakes.load(atomic::Ordering::SeqCst));
assert_eq!(Poll::Pending, fut.as_mut().poll(&mut cx));
assert_eq!(1, counter.wakes.load(atomic::Ordering::SeqCst));
assert_eq!(Poll::Ready(9), fut.as_mut().poll(&mut cx));
}
fn main() {
macro_rules! test {
($($fn_name:expr,)*) => { $(
test_future_yields_once_then_returns($fn_name);
)* }
}
macro_rules! test_with_borrow {
($($fn_name:expr,)*) => { $(
test_future_yields_once_then_returns(|x| {
async move {
await!($fn_name(&x))
}
});
)* }
}
test! {
async_block,
async_nonmove_block,
async_closure,
async_closure_in_unsafe_block,
async_fn,
generic_async_fn,
async_fn_with_internal_borrow,
async_block_in_unsafe_block,
Foo::async_assoc_item,
|x| {
async move {
unsafe { await!(unsafe_async_fn(x)) }
}
},
|x| {
async move {
unsafe { await!(Foo::async_unsafe_assoc_item(x)) }
}
},
}
test_with_borrow! {
async_block_with_borrow_named_lifetime,
async_fn_with_borrow,
async_fn_with_borrow_named_lifetime,
async_fn_with_impl_future_named_lifetime,
|x| {
async move {
await!(async_fn_multiple_args_named_lifetime(x, x))
}
},
}
}

2
src/test/ui/async-await/multiple-lifetimes/named.rs
View File

@ -3,7 +3,7 @@
// Test that we can use async fns with multiple arbitrary lifetimes.
#![feature(arbitrary_self_types, async_await, await_macro)]
#![feature(async_await)]
async fn multiple_named_lifetimes<'a, 'b>(_: &'a u8, _: &'b u8) {}

12
src/test/ui/feature-gate/await-macro.rs
View File

@ -1,12 +0,0 @@
// gate-test-await_macro
// edition:2018
#![feature(async_await)]
async fn bar() {}
async fn foo() {
await!(bar()); //~ ERROR `await!(<expr>)` macro syntax is unstable, and will soon be removed
}
fn main() {}

12
src/test/ui/feature-gate/await-macro.stderr
View File

@ -1,12 +0,0 @@
error[E0658]: `await!(<expr>)` macro syntax is unstable, and will soon be removed in favor of `<expr>.await` syntax.
--> $DIR/await-macro.rs:9:5
|
LL | await!(bar());
| ^^^^^^^^^^^^^
|
= note: for more information, see https://github.com/rust-lang/rust/issues/50547
= help: add `#![feature(await_macro)]` to the crate attributes to enable
error: aborting due to previous error
For more information about this error, try `rustc --explain E0658`.