Support mixed sync and async context managers in `async with` statements

Over the last few years, I've found myself writing a lot of code which leans heavily on context managers, and parenthesized context managers make it quite conventient to do so - in all but one case. If you have mixed synchronous and async context managers, each switch from sync to async costs another level of indentation, making the code noticably harder to read.

I therefore propose that the async with statement should also accept mixed sync and async context managers, so long as there is at least one async context manager.

I've been using a helper function which gets most of the way towards this. I nonetheless think that the feature would be valuable, because:

• It guides people away from a "convert to async cm" pattern (e.g. as_acm(sync_cm()) as v,), which changes code semantics by adding checkpoints where the async framework can switch tasks - and entering or exiting context managers is an unusally bad time to do that, since they are often responsible for timeouts or error handling.
• Keeping the as clauses local helps to avoid naming confusion: when adding or deleting code, it's easy to mismatch async with multicontext(some(), contexts()) as (a, b): relative to async with some() as b, contexts as a:. As seen here, it's also more concise.

from contextlib import AsyncExitStack, asynccontextmanager

@asynccontextmanager
async def multicontext(*cms):
    assert any(hasattr(cm, "__aenter__") for cm in cms)
    async with AsyncExitStack() as stack:
        enter, aenter = stack.enter_context, stack.enter_async_context
        yield tuple(
            (enter(cm) if hasattr(cm, "__enter__") else await aenter(cm))
            for cm in cms
        )

Has this already been discussed elsewhere?

This is a minor feature, which does not need previous discussion elsewhere.

Update: now on discuss.python.org to collect feedback.

No source files or tests are named in the issue. Start by reading the proposal and the linked discuss.python.org thread, then identify the language semantics and implementation scope for allowing mixed synchronous and asynchronous context managers. Done means the syntax and behavior are agreed and covered by appropriate tests.