Fix Promise interfaces

[falsandtru]

Fixes #11094, #3356, #21867.

@mhegazy @rbuckton Can you include this to the next release?

[rbuckton]

I don't think this specific change is necessary. PromiseConstructorLike is only used by the type system to determine if an explicit Promise-like return type in a down-level ES5 async function can be used as a Promise constructor. Changing the type could adversely affect people using this behavior.

[falsandtru]

Indeed, this change may make compatibility worse. I'll revert this.

[falsandtru]

Done.

[rbuckton]

Is the goal to only allow value to be optional if T is exactly void? If T is void | number you end up with the second definition (with a non-optional value) for (value: void | number | PromiseLike<void | number>) => void.

You could try this instead:

resolve: [void] extends [T] ? (value?: T | PromiseLike<T>) => void : (value: T | PromiseLike<T>) => void

By inverting the condition, you would get cases where void is assignable (such as when T is a union including void).

[falsandtru]

It seems a nice idea. I'll do it.

[falsandtru]

Done.

[falsandtru]

I realized [void] extends [T] doesn't work with undefined. So I reverted it.

[rbuckton]

That's unfortunate, but its better than nothing I suppose.

[rbuckton]

Have you tried this without the conditional type? This should work as well and is probably easier to read:

    new <T extends void>(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;

[falsandtru]

As I mentioned at #21867 (comment), it is not extensible.

[falsandtru]

@rbuckton Ah, I realized a problem now. In the following case, this change make an unfavorable effect.

class C<T> extends Promise<T> {
  constructor() {
    super(resolve => resolve(0 as any)); // error, can't call it.
  }
}

[weswigham]

@rbuckton Our RWC tests show this as kinda breaky, for a few reasons.

1. Generic promises may no longer yield callable resolve or reject, as the conditional type is not resolved, and you get something like ((value?: A | PromiseLike<A> | undefined) => void) | ((value: A | PromiseLike<A>) => void) as the apparent type, which do not unify and is not callable under current rules.
2. Promises where inference has failed (eg, a simple new Promise without type annotation), have a type of {}, which, by virtue of not being void, require an argument to resolve, which very much does not jibe with real-world use - in fact, in many cases new Promise() is used like a Promise<void> (and why wouldn't you).

[rbuckton]

I'm reverting this change for now.