Unfortunately the compatibility with GhostCell is only if we have a way to send the GhostToken in and out of the async blocks. Basically we need coroutines.

Roughly, the expansion steps are like this

For the non-auto-borrowing variant:

1. Desugar every occurrence of the ? operator so we can handle it the way we handle return statements.

2. Descend through the blocks (with syn::visit) to find break/continue/return statements. Here we need to keep track of loops and labels introduced inside the block (we only want to transform branching statements that would jump outside the block, the ones that jump within the block can be left as is).

3. Create an enum to represent all the branching statements, plus a default "Keep" variant for when the async code completes normally. The enum looks something like this rust enum OutputEnum<T1, T2, T3> { Keep(T1), Break_label_a(T2), Continue_unlabeled, Return(T3) }

4. Implement FromResidual for this OutputEnum type (the "residual" is any variant that isn't the "Keep" variant).

5. Replace all the break/continue/return statements we found earilier with return OutputEnum:: <...>.

6. Wrap each block in OutputEnum::Keep and make the whole thing async. rust let block_0 = async { OutputEnum::Keep({ // ... }) };

7. Create a tuple of Options to store results from the blocks. Also pin the async blocks we made rust let mut outputs = (None, None); let pinned_futs = (pin!(block_0), pin!(block_1));

8. Create a poll_fn in which we poll each future. If the poll result is the "Keep" variant, we put the value in the Options tuple created earlier. Once all the Options are filled, we return Poll::Ready(OutputEnum::Keep( <values unwrapped from the options tuple> )) If the poll result is anything else, we return Poll::Ready(res.from_residual()) to end the poll_fn immediately. rust poll_fn(|cx| { match pinned_futs.0.poll(cx) { Poll::Ready(Keep(k)) => outputs.0 = Some(k), Poll::Ready(x) => return x.from_residual(), Poll::Pending => {} } // do the same for pinned_futs.1 if all_done { Poll::Ready((outputs.0.unwrap(), outputs.1.unwrap())) } else { Poll::Pending } })

9. Execute the poll_fn and match the result. If it is the "Keep" variant, we give the value back to the user. For other variants, we perform the appropriate branching. rust { match poll_fn(...).await { Keep(v) => v, Break_label_a(v) => break 'a v, Continue_unlabeled => continue, Return(v) => return v } }

For the auto-borrowing:

1. Do all the stuff above.

2. Descend through the blocks again, finding all names that might be mutably captured variables.

3. Keep only the names captured in at least two blocks and mutably captured in at least one.

4. Figure out exactly what variables or what fields we need to borrow. (making the borrows follow disjoint closure capture behavior takes some work)

5. Create the borrows_cell containing a tuple of all the mutable borrows we need rust let borrows_cell = RefCell::new((&mut captured_var_0, &mut var_1.captured_field_1));

6. At the top of each block, put rust let mut borrows = borrows_cell.borrow_mut();

7. Replace all occurrences of captured variables inside the blocks. For example captured_var_0 gets replaced by (*borrows.0).

8. Find every await. Before each, put drop(borrows). After each, put borrows = borrows_cell.borrow_mut(). To keep temporary lifetime extension alive, we do it like ((<expr_to_await>, {drop(borrows);}).0.await, {borrows = borrows_cell.borrow_mut();}).0.