The original intent of this rule was to discourage the use of `return await`, to avoid an extra microtask. However, due to the fact that JavaScript now handles native `Promise`s differently, there is no longer an extra microtask. More technical information can be found in [this V8 blog entry](https://v8.dev/blog/fast-async).

Using `return await` inside an `async function` keeps the current function in the call stack until the Promise that is being awaited has resolved, at the cost of an extra microtask before resolving the outer Promise. `return await` can also be used in a try/catch statement to catch errors from another function that returns a Promise.

You can avoid the extra microtask by not awaiting the return value, with the trade off of the function no longer being a part of the stack trace if an error is thrown asynchronously from the Promise being returned. This can make debugging more difficult.

This rule aims to prevent a likely common performance hazard due to a lack of understanding of the semantics of `async function`.

There are a few reasons you might want to turn this rule off:

* If you want to use `await` to denote a value that is a thenable

* If you do not want the performance benefit of avoiding `return await`

* If you want the functions to show up in stack traces (useful for debugging purposes)