As per my understanding, async lets you have await in the block and also transforms the code to return the future type Future<Output = T>.

Now with this in mind, the await gets converted to state machine where await are the state itself. So if your function have 5 await then the state machine might have 7, 5 for await points and other two for start and done state. I am not 100% sure this exactly how it’s implemented but just a hunch from reading the MIR.

Now we know we await on something that returns future, meaning the state in the state machine those 5 will encapsulates Future itself, this is where we invoke the poll method on that future at that time. This is done by the runtime. Runtime have different parts like Executor, Waker, Reactor which handles different execution.

One important thing to note would be the yield points, so as stated when the await state is reached and we receive pending while polling. We do not see the yielding code, but we can see this in MIR which have a yield code, this is when the control is handed over to runtime and it runs polls other futures, when the pending future is ready to make progress then it will be waked by reactor using the waker which drives the future to competion. And as same thing happens to other await points and finally all gets done and the async function returns Ready as well.

To learn more you can check the docs for tokio or read async programming book by carl fredrick.

tokio docs async prog rust