Promise.all not correctly inferring types.

[afrieder]

TypeScript Version: 3.7.2, v3.8.0-dev.20191102

Search Terms:
Promise.all
Wrong type

Code

const f1 = async (): Promise<string> => {
    return '';
};

const f2 = async (): Promise<number> => {
    return 0;
};

const f3 = async (): Promise<Object> => {
    return {};
};

const res = Promise.all([f1(), f2(), f3()]);

Expected behavior:
res has type Promise<[string, number, Object]>.

Actual behavior:
res has type Promise<Object[]>.

Playground Link:
http://www.typescriptlang.org/play/?ts=3.8.0-dev.20191102&ssl=2&ssc=1&pln=5&pc=1#code/MYewdgzgLgBAZgRhgXhgQwgTzMGAKASgC4YAFAJxAFsBLCAUwB5pyawBzAPhW4G8AoGEJjl6UAK7kwMAOQyA3PwC+-fqEiw4AJhTosOfMTKVaDRmHFUARvXLdkfQcNESpMAAyKVa8NHgBmXQxsXEISCmo6JgB5KwAremAoe0dhETFJaV4lL1V1P1EIXQjTegA6NAAbSrwAbURCABp4LSaAwgBdAnkgA

Related Issues:

[nmain]

Possible duplicate of #34924

[AnyhowStep]

Not a duplicate. Also shown that this PR, as it is, will not fix this issue.

#33707

#33707 (comment)

[stevehollaar]

I have another Playground link example of Promise.all inferring types incorrectly. It seems when one of the results is nullable, TS incorrectly makes all results nullable:
http://www.typescriptlang.org/play/?ssl=8&ssc=1&pln=8&pc=5#code/MYewdgzgLgBAZgUysAFgRhgXhgCgJQBcMACgE4gC2AlhAgDxgCuFARgqTAD4xMA2vAPixCylGggB0pBBBC8Abghxo8AbgBQoSLETIUAJiy5CJctVp1opKmADmAbQC6QzCLPipMuYpz2A5ACGfgA0MH4sfo5q6prg0DABRgEQAJ5gwMbCMADe6jAwWvH2pGihpPqORPZMrOycfLyhVjYOjo5JAO4BVLCi5pIB-L66qGj4oSMG+FEa+YVykrwgtjglweV46gC+6gH4qkA

[AnyhowStep]

@stevehollaar

#33707 will fix that example.

type Awaited<T> =
    T extends undefined ?
    T :
    T extends PromiseLike<infer U> ?
    U :
    T
;
declare function all<T extends readonly any[]>(
    values: T
): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

//for empty tuple
declare function betterAll (arr : []) : Promise<[]>;
//for non-empty tuple
declare function betterAll<ArrT extends readonly [any, ...any[]]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;
//for non-tuple array
declare function betterAll<ArrT extends readonly any[]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;

//https://github.com/microsoft/TypeScript/issues/34925#issuecomment-550021453
const fetch1 = (): Promise<number | null> => Promise.resolve(1);
const fetch2 = (): Promise<string[]> => Promise.resolve(['a', 'b']);

async () => {
  //Error
  const [r1, r2]: [number|null, string[]] = await Promise.all([fetch1(), fetch2()]);
  console.log(r1,r2)
}

async () => {
  //OK
  const [r1, r2]: [number|null, string[]] = await all([fetch1(), fetch2()]);
  console.log(r1,r2)
}

async () => {
  //OK
  const [r1, r2]: [number|null, string[]] = await betterAll([fetch1(), fetch2()]);
  console.log(r1,r2)
}

async () => {
  //OK
  //const r1: number | null
  //const r2: string[]
  const [r1, r2] = await all([fetch1(), fetch2()]);
  console.log(r1,r2)
}

async () => {
  //OK
  //const r1: number | null
  //const r2: string[]
  const [r1, r2] = await betterAll([fetch1(), fetch2()]);
  console.log(r1,r2)
}

Playground

[junoatwork]

Here's another example I have of Promise.all behavior changes in 3.7.2 vs 3.6. I tried testing it with the new declarations in #33707 but it has the same error result.

/* eslint-disable */
type Awaited<T> = T extends undefined ? T : T extends PromiseLike<infer U> ? U : T;

function all<T extends readonly any[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>{
  return Promise.all(values) as any;
}

class K {
  getA = (): Promise<string | undefined> => {
    return Promise.resolve(undefined);
  };
  getB = (): Promise<string> => {
    return Promise.resolve('');
  };

  getC() {
    // working in 3.6.3, error in 3.7.2
    Promise.all([this.getA(), this.getB()]).then(([a, b]) => {
      const a_: string | undefined = a;
      // ts2322, b is inferred as `string | undefined`
      const b_: string = b;

      return [a_, b_];
    });

    // attempt to test with new type in PR #33707, same result
    all([this.getA(), this.getB()]).then(([a, b]) => {
      const a_: string | undefined = a;
      // ts2322, b is inferred as `string | undefined`
      const b_: string = b;

      return [a_, b_];
    });
  }
}

[AnyhowStep]

I'm on mobile, so I can't try it but can you try the betterAll declaration?

[thaoula]

We have quite a few Promise.all and array destructuring statements in our codebase. Most are working like the Typescript 3.6.3 version except any statement that involves promises returning any.

Whenever any promise in the Promise.all call returns any all the destructured variables are marked as any.

[AnyhowStep]

@junoatscroll

type Awaited<T> =
    T extends undefined ?
    T :
    T extends PromiseLike<infer U> ?
    U :
    T
;
declare function all<T extends readonly any[]>(
    values: T
): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

//for empty tuple
declare function betterAll (arr : []) : Promise<[]>;
//for non-empty tuple
declare function betterAll<ArrT extends readonly [any, ...any[]]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;
//for non-tuple array
declare function betterAll<ArrT extends readonly any[]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;

//https://github.com/microsoft/TypeScript/issues/34925#issuecomment-550069150
class K {
  getA = (): Promise<string | undefined> => {
    return Promise.resolve(undefined);
  };
  getB = (): Promise<string> => {
    return Promise.resolve('');
  };

  getC() {
    // working in 3.6.3, error in 3.7.2
    Promise.all([this.getA(), this.getB()]).then(([a, b]) => {
      const a_: string | undefined = a;
      // ts2322, b is inferred as `string | undefined`
      const b_: string = b;

      return [a_, b_];
    });

    // attempt to test with new type in PR #33707, same result
    all([this.getA(), this.getB()]).then(([a, b]) => {
      const a_: string | undefined = a;
      // ts2322, b is inferred as `string | undefined`
      const b_: string = b;

      return [a_, b_];
    });

    betterAll([this.getA(), this.getB()]).then(([a, b]) => {
      const a_: string | undefined = a;
      //OK!
      const b_: string = b;

      return [a_, b_];
    });
  }
}

Playground

The betterAll() type works for your use case

[AnyhowStep]

@thaoula

type Awaited<T> =
    T extends undefined ?
    T :
    T extends PromiseLike<infer U> ?
    U :
    T
;
declare function all<T extends readonly any[]>(
    values: T
): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

//for empty tuple
declare function betterAll (arr : []) : Promise<[]>;
//for non-empty tuple
declare function betterAll<ArrT extends readonly [any, ...any[]]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;
//for non-tuple array
declare function betterAll<ArrT extends readonly any[]>(
    arr: ArrT
): Promise<{ -readonly [i in keyof ArrT]: Awaited<ArrT[i]> }>;

//https://github.com/microsoft/TypeScript/issues/34925#issuecomment-550092250
//const res0: Promise<any[]>
const res0 = Promise.all([Promise.resolve(1), Promise.resolve(null as any)]);
//const res1: Promise<any[]>
const res1 = all([Promise.resolve(1), Promise.resolve(null as any)]);
//const res2: Promise<[number, any]>
const res2 = betterAll([Promise.resolve(1), Promise.resolve(null as any)]);

Playground