Contextually type 'await ...' whose value is unused to 'void | PromiseLike<void>'

[rbuckton]

Search Terms

contextual type await void

Suggestion

When contextually typing an await whose expression is unused, we should use the contextual type of void:

// "today" assumes https://github.com/microsoft/TypeScript/pull/39817
async function foo() {
  // today: Promise<unknown>
  // proposed: Promise<void>
  await new Promise(resolve => {
    // today: (value: unknown) => void
    // proposed: (value: void) => void
    resolve();
  });
}

A statement like await new Promise(...) is commonly used to adapt a callback-based API where the result isn't value (such as Node's fs.writeFile). Once #39817 merges, the value argument for the resolve callback will no longer be optional unless it contains void. Since the result of the await expression above is unused, we should use void as the contextual type for the await, so that the contextual type for its operand becomes void | PromiseLike<void>, thus contextually typing the Promise construction.

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code:
  • This will require testing to verify
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[glasser]

This would be super nice! For example, we have docs that encourage the pattern await new Promise(resolve => server.listen(PORT, resolve)). It would be nice if this worked without <void>, especially because it would enable the same code to work in JS and TS.