# Async magic methods in contextlib.closing

I think `__aenter__` and `__aexit__` methods should be added to `contextlib.closing`, so that we can use `contextlib.closing` in async code too.

For example:

```python3
class SomeAPI:
    ...

    async def request(self):
        pass

    async def close(self):
        await self.session.close()
        

async with closing(SomeAPI()) as api:
    response = await api.request()
    print(response)
```

Also these methods can be moved to another class (like `asyncclosing` along the lines of `asynccontextmanager`).

And what happen when you accidentally use synchronous "with" instead of "async with" with closing()?

with closing(SomeAPI()) as api:
    ...

I think it is intentionally that different functions/methods/classes are used for synchronous and asynchronous operations.

In this case:

```python3
class A:
    async def close(self):
        pass
    
with closing(A()):
    pass
```

Python will raise `RuntimeWarning: coroutine 'A.close' was never awaited`.

In another case:

```python3
class B:
    def close(self):
        pass
    
async with closing(B()):
    pass
```

Python will raise `TypeError: object NoneType can't be used in 'await' expression` (because it will try to await result of close method).

-----

I was surprised that `contextlib` has no async analogue of this `closing` class, because async scripts often use any kind of closings. Do you think it's better to extract to `asyncclosing` class?

This seems to be a duplicate of issue40213 with a link to implementation in trio.

Warning is not error. It may left unnoticed, especially if the code is executed on server. And in this particular case turning the warning into exception by setting warning filters does not help, because it would be raised in the context where exceptions are swallowed.

I'm OK with adding this, but the close method should be `aclose()`