When writing an `async` function, we often want to `await` a method call that may or may not be `async`.  For instance, it may be synchronous in the base class, but asynchronous in the subclass on the instance we have been given.  It would be nice for `await foo` to be a no-op if `foo` does not have an `__await__` method.  For instance, the following works in EMCAScript 2017:  `async function foo () { let bar = await 1; console.log(bar); }`.  As a workaround, we have been using `await force_async(foo.bar)`, where `force_async` is the following:

```python
async def force_async(obj):
    """Force an object to be asynchronous"""
    if hasattr(obj, '__await__'):
        return await obj
    async def inner():
        return obj
    return await inner()
```

This functionality is roughly equivalent to `gen.maybe_future` for coroutines, that is now deprecated in Tornado.  cf http://www.tornadoweb.org/en/stable/gen.html#tornado.gen.maybe_future

This isn't something we want to do in Python.  We have a dynamic but strict type system. 1 + '1' is an error in Python, but works just fine in JavaScript.  Likewise, in 'await foo' foo is expected to be an awaitable in Python and not anything else.  This has been discussed multiple times during PEP 492 approval process.

I've been beaten myself by lose semantics of await in JS by awaiting a function that returned null—a simple bug that turned out to be a nightmare to identify in a complex system.

So unfortunately I have to close this one as "won't fix", sorry. Thank you for suggesting the idea though.

Thanks for your consideration and for implementing the original feature!