New rule: enforce async/await consistency

Please describe what the rule should do:

• Enforce that all functions marked as async are being awaited when called.
• Enforce that all functons that are being awaited be marked as async.
• Prohibit awaiting functions that are not returning promises.

What category of rule is this? (place an “X” next to just one item)

[ ] Enforces code style [x] Warns about a potential error [ ] Suggests an alternate way of doing something [ ] Other (please specify:)

Provide 2-3 code examples that this rule will warn about:

<!-- put your code examples here -->
function foo1(){  };
async function foo2(){ };
async function foo3(){ };

async function bar1(){
    const x = foo1(); // ok
    const y = foo2(); // error
}

async function bar2(){
    const x = await foo1(); // error
    const y = await foo2(); // ok
}

async function bar3(){
    Promise.all([foo2(), foo3()]); // error
}

async function bar4(){
    await Promise.all([foo2(), foo3()]); // ok
}

Why should this rule be included in ESLint (instead of a plugin)?

Because I think this is core to the language.

[not-an-aardvark]

Thanks for your interest in improving ESLint. Unfortunately, it looks like this issue didn’t get consensus from the team, so I’m closing it. We define consensus as having three 👍s from team members, as well as a team member willing to champion the proposal. This is a high bar by design – we can’t realistically accept and maintain every feature request in the long term, so we only accept feature requests which are useful enough that there is a strong consensus among the team that they’re worth adding.

Since ESLint is pluggable and can load custom rules at runtime, the lack of consensus among the ESLint team doesn’t need to be a blocker for you using this in your project, if you’d find it useful. It just means that you would need to implement the rule yourself, rather than using a bundled rule that is packaged with ESLint.

[ljharb]

This is what a type system and/or tests are for; this just isn’t a lintable problem.