Error with async generators

[falsandtru]

@rbuckton

TypeScript Version: master

Search Terms:

Code

const g: <U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>) => Promise<U> = async <U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>): Promise<U> => {
  throw com;
};

Expected behavior:
pass
Actual behavior:

index.ts:1:7 - error TS2719: Type '<U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>) => Promise<U>' is not assignable to type '<U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>) => Promise<U>'. Two different types with this name exist, but they are unrelated.
  Type 'Promise<U | PromiseLike<U>>' is not assignable to type 'Promise<U>'.
    Type 'U | PromiseLike<U>' is not assignable to type 'U'.
      'U | PromiseLike<U>' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint '{}'.
        Type 'PromiseLike<U>' is not assignable to type 'U'.
          'PromiseLike<U>' is assignable to the constraint of type 'U', but 'U' could be instantiated with a different subtype of constraint '{}'.

1 const g: <U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>) => Promise<U> = async <U, R, S>(com: () => Iterator<S, U, R> | AsyncIterator<S, U, R>): Promise<U> => {
        ~

Playground Link:

Related Issues:

[rbuckton]

It doesn't seem to like the definitions of TNext | PromiseLike<TNext> and TReturn | PromiseLike<TReturn> for the next() and return() methods.

[falsandtru]

Yes, the actual type is not assignable to the declared type although they are the same type.

[falsandtru]

@rbuckton Please don't forget this too.

[rbuckton]

@ahejlsberg for reference

[ahejlsberg]

This appears to be unaffected by #32460. Best I can tell the issue is that Iterator and AsyncIterator are alike enough that inference succeeds in inferring from either to either--and therefore gets confused.

[ahejlsberg]

A simpler repro:

interface Foo<T> {
    test(value: T): void;
}

interface Bar<T> {
    test(value: T | PromiseLike<T>): void;
}

declare let f1: <T>(x: Foo<T> | Bar<T>) => Promise<T>;
declare let f2: <U>(x: Foo<U> | Bar<U>) => Promise<U>;

f1 = f2;  // Error
f2 = f1;  // Error