Confusing error from an incorrect `return;` in `async` block

[spaarmann]

This code compiles without errors:

async fn foo() -> Result<(), Box<dyn std::error::Error>> {
    async {
        Err(anyhow!("oh no"))?;
        Ok(())
    }.await
}

Adding a return; in the middle of the async block makes this code wrong

async fn foo() -> Result<(), Box<dyn std::error::Error>> {
    async {
        Err(anyhow!("oh no"))?;
        return;
        Ok(())
    }.await
}

and rustc correctly produces an error. Playground link
However, the error is very confusing:

error[E0277]: the `?` operator can only be used in an async block that returns `Result` or `Option` (or another type that implements `FromResidual`)
  --> src/lib.rs:27:30
   |
26 |       async {
   |  ___________-
27 | |         Err(anyhow!("oh no"))?;
   | |                              ^ cannot use the `?` operator in an async block that returns `()`
28 | |         return;
29 | |         Ok(())
30 | |     }.await
   | |_____- this function should return `Result` or `Option` to accept `?`
   |
   = help: the trait `FromResidual<Result<Infallible, anyhow::Error>>` is not implemented for `()`

error[E0308]: mismatched types
  --> src/lib.rs:29:9
   |
29 |         Ok(())
   |         ^^^^^^ expected `()`, found enum `Result`
   |
   = note: expected type `()`
              found enum `Result<(), _>`
note: return type inferred to be `()` here
  --> src/lib.rs:27:9
   |
27 |         Err(anyhow!("oh no"))?;
   |         ^^^^^^^^^^^^^^^^^^^^^^

error[E0308]: mismatched types
  --> src/lib.rs:26:5
   |
26 | /     async {
27 | |         Err(anyhow!("oh no"))?;
28 | |         return;
29 | |         Ok(())
30 | |     }.await
   | |___________^ expected enum `Result`, found `()`
   |
   = note:   expected enum `Result<(), Box<(dyn std::error::Error + 'static)>>`
           found unit type `()`
help: try adding an expression at the end of the block
   |
30 ~     }.await;
31 +     Ok(())
   |

It simultaneously complains in the first error that the ? is invalid because the async block returns () and then in the next error it says that it inferred the return type to be () because of that ?.

Ideally the compiler could figure out based on the return type of the function that the return; is the problem here, but at the very least it would be good to not point at the Err(...)? line as the reason for the return type being inferred as ().

Tested on stable 1.59 and nightly 1.61 (2022-03-16).

[spaarmann]

The playground link also contains a version of this using tokio::main instead of an async block within an async fn. This hides the real issue a bit more, but on top, it also makes the suggestion at the end extra confusing:

error[[E0308]](https://doc.rust-lang.org/nightly/error-index.html#E0308): mismatched types
  [--> src/lib.rs:15:5
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
12 | async fn main() -> Result<(), Box<dyn std::error::Error>> {
   |                    -------------------------------------- expected `Result<(), Box<(dyn std::error::Error + 'static)>>` because of return type
...
15 |     Ok(())
   |     ^^^^^^ expected enum `Result`, found `()`
   |
   = note:   expected enum `Result<(), Box<(dyn std::error::Error + 'static)>>`
           found unit type `()`
help: try adding an expression at the end of the block
   |
15 ~     Ok(());
16 +     Ok(())
   |

"Try Ok(()); Ok(()) instead of Ok(())" is not great. I suspect this is related more to the spans set by tokio::main than what the compiler does, but I figured I'd mention it.