error: future cannot be sent between threads safely
  --> $DIR/async-await-let-else.rs:45:13
   |
LL |     is_send(foo(Some(true)));
   |             ^^^^^^^^^^^^^^^ future returned by `foo` is not `Send`
   |
   = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `Rc<()>`
note: future is not `Send` as this value is used across an await
  --> $DIR/async-await-let-else.rs:8:15
   |
LL |         let r = Rc::new(());
   |             - has type `Rc<()>` which is not `Send`
LL |         bar().await
   |               ^^^^^ await occurs here, with `r` maybe used later
note: required by a bound in `is_send`
  --> $DIR/async-await-let-else.rs:16:15
   |
LL | fn is_send<T: Send>(_: T) {}
   |               ^^^^ required by this bound in `is_send`

error[E0277]: `Rc<()>` cannot be sent between threads safely
  --> $DIR/async-await-let-else.rs:47:13
   |
LL | async fn foo2(x: Option<bool>) {
   | ------------------------------ within this `impl Future<Output = ()>`
...
LL |     is_send(foo2(Some(true)));
   |     ------- ^^^^^^^^^^^^^^^^ `Rc<()>` cannot be sent between threads safely
   |     |
   |     required by a bound introduced by this call
   |
   = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `Rc<()>`
note: required because it's used within this `async` fn body
  --> $DIR/async-await-let-else.rs:24:29
   |
LL |   async fn bar2<T>(_: T) -> ! {
   |  _____________________________^
LL | |     panic!()
LL | | }
   | |_^
note: required because it's used within this `async` fn body
  --> $DIR/async-await-let-else.rs:18:32
   |
LL |   async fn foo2(x: Option<bool>) {
   |  ________________________________^
LL | |     let Some(_) = x else {
LL | |         bar2(Rc::new(())).await
LL | |     };
LL | | }
   | |_^
note: required by a bound in `is_send`
  --> $DIR/async-await-let-else.rs:16:15
   |
LL | fn is_send<T: Send>(_: T) {}
   |               ^^^^ required by this bound in `is_send`

error: future cannot be sent between threads safely
  --> $DIR/async-await-let-else.rs:49:13
   |
LL |     is_send(foo3(Some(true)));
   |             ^^^^^^^^^^^^^^^^ future returned by `foo3` is not `Send`
   |
   = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `Rc<()>`
note: future is not `Send` as this value is used across an await
  --> $DIR/async-await-let-else.rs:30:29
   |
LL |         (Rc::new(()), bar().await);
   |          -----------        ^^^^^ await occurs here, with `Rc::new(())` maybe used later
   |          |
   |          has type `Rc<()>` which is not `Send`
note: required by a bound in `is_send`
  --> $DIR/async-await-let-else.rs:16:15
   |
LL | fn is_send<T: Send>(_: T) {}
   |               ^^^^ required by this bound in `is_send`

error: future cannot be sent between threads safely
  --> $DIR/async-await-let-else.rs:51:13
   |
LL |     is_send(foo4(Some(true)));
   |             ^^^^^^^^^^^^^^^^ future returned by `foo4` is not `Send`
   |
   = help: within `impl Future<Output = ()>`, the trait `Send` is not implemented for `Rc<()>`
note: future is not `Send` as this value is used across an await
  --> $DIR/async-await-let-else.rs:38:15
   |
LL |         let r = Rc::new(());
   |             - has type `Rc<()>` which is not `Send`
LL |         bar().await;
   |               ^^^^^ await occurs here, with `r` maybe used later
note: required by a bound in `is_send`
  --> $DIR/async-await-let-else.rs:16:15
   |
LL | fn is_send<T: Send>(_: T) {}
   |               ^^^^ required by this bound in `is_send`

error: aborting due to 4 previous errors

For more information about this error, try `rustc --explain E0277`.
