The semantics of this feature are unclear; do these all execute concurrently or just one after another?
If you want them to run concurrently, you should use the join macro provided by a library like futures, tokio, or async-std. If you are on nightly, such a macro is available in std as well: join in std::future - Rust
let a = foo().await?;
let b = a.bar()?.baz().await;
let c = b.qux().await?;
If you turn it into an await block, how does the compiler know which expressions to await? If it automatically awaits everything that implements IntoFuture, the control flow becomes implicit, which is the opposite of what we tried to achieve with async/await.
.await is easy to write and very clear. This creates rightward drift, and loses local explicitness of the await points.
Indentation and braces don't even make the code more compact.
Because it's a block, it also complicates keeping results returned from functions inside the block (needs bindings declared earlier or some kind of super let).
Serial execution of async functions without data inter-dependencies seems like a wasted opportunity to run them concurrently.